1#[allow(unused_imports)]
13use serde_json::Value;
14
15#[derive(Debug, Serialize, Deserialize)]
16pub struct Ledger {
17 #[serde(rename = "acctcode")]
18 acctcode: Option<String>,
19 #[serde(rename = "cashbalance")]
20 cashbalance: Option<f32>,
21 #[serde(rename = "commoditymarketvalue")]
22 commoditymarketvalue: Option<f32>,
23 #[serde(rename = "corporatebondsmarketvalue")]
24 corporatebondsmarketvalue: Option<f32>,
25 #[serde(rename = "currency")]
26 currency: Option<String>,
27 #[serde(rename = "exchangerate")]
28 exchangerate: Option<f32>,
29 #[serde(rename = "funds")]
30 funds: Option<f32>,
31 #[serde(rename = "futuremarketvalue")]
32 futuremarketvalue: Option<f32>,
33 #[serde(rename = "interest")]
34 interest: Option<f32>,
35 #[serde(rename = "issueroptionsmarketvalue")]
36 issueroptionsmarketvalue: Option<f32>,
37 #[serde(rename = "key")]
38 key: Option<String>,
39 #[serde(rename = "moneyfunds")]
40 moneyfunds: Option<f32>,
41 #[serde(rename = "netliquidationvalue")]
42 netliquidationvalue: Option<f32>,
43 #[serde(rename = "realizedpnl")]
44 realizedpnl: Option<f32>,
45 #[serde(rename = "sessionid")]
46 sessionid: Option<i32>,
47 #[serde(rename = "settledcash")]
48 settledcash: Option<f32>,
49 #[serde(rename = "severity")]
50 severity: Option<i32>,
51 #[serde(rename = "stockmarketvalue")]
52 stockmarketvalue: Option<f32>,
53 #[serde(rename = "timestamp")]
54 timestamp: Option<i32>,
55 #[serde(rename = "unrealizedpnl")]
56 unrealizedpnl: Option<f32>,
57 #[serde(rename = "warrantsmarketvalue")]
58 warrantsmarketvalue: Option<f32>
59}
60
61impl Ledger {
62 pub fn new() -> Ledger {
63 Ledger {
64 acctcode: None,
65 cashbalance: None,
66 commoditymarketvalue: None,
67 corporatebondsmarketvalue: None,
68 currency: None,
69 exchangerate: None,
70 funds: None,
71 futuremarketvalue: None,
72 interest: None,
73 issueroptionsmarketvalue: None,
74 key: None,
75 moneyfunds: None,
76 netliquidationvalue: None,
77 realizedpnl: None,
78 sessionid: None,
79 settledcash: None,
80 severity: None,
81 stockmarketvalue: None,
82 timestamp: None,
83 unrealizedpnl: None,
84 warrantsmarketvalue: None
85 }
86 }
87
88 pub fn set_acctcode(&mut self, acctcode: String) {
89 self.acctcode = Some(acctcode);
90 }
91
92 pub fn with_acctcode(mut self, acctcode: String) -> Ledger {
93 self.acctcode = Some(acctcode);
94 self
95 }
96
97 pub fn acctcode(&self) -> Option<&String> {
98 self.acctcode.as_ref()
99 }
100
101 pub fn reset_acctcode(&mut self) {
102 self.acctcode = None;
103 }
104
105 pub fn set_cashbalance(&mut self, cashbalance: f32) {
106 self.cashbalance = Some(cashbalance);
107 }
108
109 pub fn with_cashbalance(mut self, cashbalance: f32) -> Ledger {
110 self.cashbalance = Some(cashbalance);
111 self
112 }
113
114 pub fn cashbalance(&self) -> Option<&f32> {
115 self.cashbalance.as_ref()
116 }
117
118 pub fn reset_cashbalance(&mut self) {
119 self.cashbalance = None;
120 }
121
122 pub fn set_commoditymarketvalue(&mut self, commoditymarketvalue: f32) {
123 self.commoditymarketvalue = Some(commoditymarketvalue);
124 }
125
126 pub fn with_commoditymarketvalue(mut self, commoditymarketvalue: f32) -> Ledger {
127 self.commoditymarketvalue = Some(commoditymarketvalue);
128 self
129 }
130
131 pub fn commoditymarketvalue(&self) -> Option<&f32> {
132 self.commoditymarketvalue.as_ref()
133 }
134
135 pub fn reset_commoditymarketvalue(&mut self) {
136 self.commoditymarketvalue = None;
137 }
138
139 pub fn set_corporatebondsmarketvalue(&mut self, corporatebondsmarketvalue: f32) {
140 self.corporatebondsmarketvalue = Some(corporatebondsmarketvalue);
141 }
142
143 pub fn with_corporatebondsmarketvalue(mut self, corporatebondsmarketvalue: f32) -> Ledger {
144 self.corporatebondsmarketvalue = Some(corporatebondsmarketvalue);
145 self
146 }
147
148 pub fn corporatebondsmarketvalue(&self) -> Option<&f32> {
149 self.corporatebondsmarketvalue.as_ref()
150 }
151
152 pub fn reset_corporatebondsmarketvalue(&mut self) {
153 self.corporatebondsmarketvalue = None;
154 }
155
156 pub fn set_currency(&mut self, currency: String) {
157 self.currency = Some(currency);
158 }
159
160 pub fn with_currency(mut self, currency: String) -> Ledger {
161 self.currency = Some(currency);
162 self
163 }
164
165 pub fn currency(&self) -> Option<&String> {
166 self.currency.as_ref()
167 }
168
169 pub fn reset_currency(&mut self) {
170 self.currency = None;
171 }
172
173 pub fn set_exchangerate(&mut self, exchangerate: f32) {
174 self.exchangerate = Some(exchangerate);
175 }
176
177 pub fn with_exchangerate(mut self, exchangerate: f32) -> Ledger {
178 self.exchangerate = Some(exchangerate);
179 self
180 }
181
182 pub fn exchangerate(&self) -> Option<&f32> {
183 self.exchangerate.as_ref()
184 }
185
186 pub fn reset_exchangerate(&mut self) {
187 self.exchangerate = None;
188 }
189
190 pub fn set_funds(&mut self, funds: f32) {
191 self.funds = Some(funds);
192 }
193
194 pub fn with_funds(mut self, funds: f32) -> Ledger {
195 self.funds = Some(funds);
196 self
197 }
198
199 pub fn funds(&self) -> Option<&f32> {
200 self.funds.as_ref()
201 }
202
203 pub fn reset_funds(&mut self) {
204 self.funds = None;
205 }
206
207 pub fn set_futuremarketvalue(&mut self, futuremarketvalue: f32) {
208 self.futuremarketvalue = Some(futuremarketvalue);
209 }
210
211 pub fn with_futuremarketvalue(mut self, futuremarketvalue: f32) -> Ledger {
212 self.futuremarketvalue = Some(futuremarketvalue);
213 self
214 }
215
216 pub fn futuremarketvalue(&self) -> Option<&f32> {
217 self.futuremarketvalue.as_ref()
218 }
219
220 pub fn reset_futuremarketvalue(&mut self) {
221 self.futuremarketvalue = None;
222 }
223
224 pub fn set_interest(&mut self, interest: f32) {
225 self.interest = Some(interest);
226 }
227
228 pub fn with_interest(mut self, interest: f32) -> Ledger {
229 self.interest = Some(interest);
230 self
231 }
232
233 pub fn interest(&self) -> Option<&f32> {
234 self.interest.as_ref()
235 }
236
237 pub fn reset_interest(&mut self) {
238 self.interest = None;
239 }
240
241 pub fn set_issueroptionsmarketvalue(&mut self, issueroptionsmarketvalue: f32) {
242 self.issueroptionsmarketvalue = Some(issueroptionsmarketvalue);
243 }
244
245 pub fn with_issueroptionsmarketvalue(mut self, issueroptionsmarketvalue: f32) -> Ledger {
246 self.issueroptionsmarketvalue = Some(issueroptionsmarketvalue);
247 self
248 }
249
250 pub fn issueroptionsmarketvalue(&self) -> Option<&f32> {
251 self.issueroptionsmarketvalue.as_ref()
252 }
253
254 pub fn reset_issueroptionsmarketvalue(&mut self) {
255 self.issueroptionsmarketvalue = None;
256 }
257
258 pub fn set_key(&mut self, key: String) {
259 self.key = Some(key);
260 }
261
262 pub fn with_key(mut self, key: String) -> Ledger {
263 self.key = Some(key);
264 self
265 }
266
267 pub fn key(&self) -> Option<&String> {
268 self.key.as_ref()
269 }
270
271 pub fn reset_key(&mut self) {
272 self.key = None;
273 }
274
275 pub fn set_moneyfunds(&mut self, moneyfunds: f32) {
276 self.moneyfunds = Some(moneyfunds);
277 }
278
279 pub fn with_moneyfunds(mut self, moneyfunds: f32) -> Ledger {
280 self.moneyfunds = Some(moneyfunds);
281 self
282 }
283
284 pub fn moneyfunds(&self) -> Option<&f32> {
285 self.moneyfunds.as_ref()
286 }
287
288 pub fn reset_moneyfunds(&mut self) {
289 self.moneyfunds = None;
290 }
291
292 pub fn set_netliquidationvalue(&mut self, netliquidationvalue: f32) {
293 self.netliquidationvalue = Some(netliquidationvalue);
294 }
295
296 pub fn with_netliquidationvalue(mut self, netliquidationvalue: f32) -> Ledger {
297 self.netliquidationvalue = Some(netliquidationvalue);
298 self
299 }
300
301 pub fn netliquidationvalue(&self) -> Option<&f32> {
302 self.netliquidationvalue.as_ref()
303 }
304
305 pub fn reset_netliquidationvalue(&mut self) {
306 self.netliquidationvalue = None;
307 }
308
309 pub fn set_realizedpnl(&mut self, realizedpnl: f32) {
310 self.realizedpnl = Some(realizedpnl);
311 }
312
313 pub fn with_realizedpnl(mut self, realizedpnl: f32) -> Ledger {
314 self.realizedpnl = Some(realizedpnl);
315 self
316 }
317
318 pub fn realizedpnl(&self) -> Option<&f32> {
319 self.realizedpnl.as_ref()
320 }
321
322 pub fn reset_realizedpnl(&mut self) {
323 self.realizedpnl = None;
324 }
325
326 pub fn set_sessionid(&mut self, sessionid: i32) {
327 self.sessionid = Some(sessionid);
328 }
329
330 pub fn with_sessionid(mut self, sessionid: i32) -> Ledger {
331 self.sessionid = Some(sessionid);
332 self
333 }
334
335 pub fn sessionid(&self) -> Option<&i32> {
336 self.sessionid.as_ref()
337 }
338
339 pub fn reset_sessionid(&mut self) {
340 self.sessionid = None;
341 }
342
343 pub fn set_settledcash(&mut self, settledcash: f32) {
344 self.settledcash = Some(settledcash);
345 }
346
347 pub fn with_settledcash(mut self, settledcash: f32) -> Ledger {
348 self.settledcash = Some(settledcash);
349 self
350 }
351
352 pub fn settledcash(&self) -> Option<&f32> {
353 self.settledcash.as_ref()
354 }
355
356 pub fn reset_settledcash(&mut self) {
357 self.settledcash = None;
358 }
359
360 pub fn set_severity(&mut self, severity: i32) {
361 self.severity = Some(severity);
362 }
363
364 pub fn with_severity(mut self, severity: i32) -> Ledger {
365 self.severity = Some(severity);
366 self
367 }
368
369 pub fn severity(&self) -> Option<&i32> {
370 self.severity.as_ref()
371 }
372
373 pub fn reset_severity(&mut self) {
374 self.severity = None;
375 }
376
377 pub fn set_stockmarketvalue(&mut self, stockmarketvalue: f32) {
378 self.stockmarketvalue = Some(stockmarketvalue);
379 }
380
381 pub fn with_stockmarketvalue(mut self, stockmarketvalue: f32) -> Ledger {
382 self.stockmarketvalue = Some(stockmarketvalue);
383 self
384 }
385
386 pub fn stockmarketvalue(&self) -> Option<&f32> {
387 self.stockmarketvalue.as_ref()
388 }
389
390 pub fn reset_stockmarketvalue(&mut self) {
391 self.stockmarketvalue = None;
392 }
393
394 pub fn set_timestamp(&mut self, timestamp: i32) {
395 self.timestamp = Some(timestamp);
396 }
397
398 pub fn with_timestamp(mut self, timestamp: i32) -> Ledger {
399 self.timestamp = Some(timestamp);
400 self
401 }
402
403 pub fn timestamp(&self) -> Option<&i32> {
404 self.timestamp.as_ref()
405 }
406
407 pub fn reset_timestamp(&mut self) {
408 self.timestamp = None;
409 }
410
411 pub fn set_unrealizedpnl(&mut self, unrealizedpnl: f32) {
412 self.unrealizedpnl = Some(unrealizedpnl);
413 }
414
415 pub fn with_unrealizedpnl(mut self, unrealizedpnl: f32) -> Ledger {
416 self.unrealizedpnl = Some(unrealizedpnl);
417 self
418 }
419
420 pub fn unrealizedpnl(&self) -> Option<&f32> {
421 self.unrealizedpnl.as_ref()
422 }
423
424 pub fn reset_unrealizedpnl(&mut self) {
425 self.unrealizedpnl = None;
426 }
427
428 pub fn set_warrantsmarketvalue(&mut self, warrantsmarketvalue: f32) {
429 self.warrantsmarketvalue = Some(warrantsmarketvalue);
430 }
431
432 pub fn with_warrantsmarketvalue(mut self, warrantsmarketvalue: f32) -> Ledger {
433 self.warrantsmarketvalue = Some(warrantsmarketvalue);
434 self
435 }
436
437 pub fn warrantsmarketvalue(&self) -> Option<&f32> {
438 self.warrantsmarketvalue.as_ref()
439 }
440
441 pub fn reset_warrantsmarketvalue(&mut self) {
442 self.warrantsmarketvalue = None;
443 }
444
445}
446
447
448