XROAD
xroad_objects_types.h
Go to the documentation of this file.
1 
6 #pragma once
7 
9 #include <common/xroad_string.h>
10 #include <common/xroad_binary.h>
11 #include <node/xroad_node_types.h>
12 #include <stdint.h>
13 #include <stdbool.h>
14 
15 #ifdef __cplusplus
16 extern "C"
17 {
18 #endif
19 
20 typedef enum
21 {
22  xroad_object_type_start = 1,
23  xroad_object_type_stop = 2,
24  xroad_object_type_reconfig = 3,
25  xroad_object_type_activate = 4,
26  xroad_object_type_deactivate = 5,
27  xroad_object_type_date_changed = 6,
28  xroad_object_type_reset = 7,
29  xroad_object_type_alarm = 8,
30  xroad_object_type_node_event = 9,
31  xroad_object_type_ping = 10,
32  xroad_object_type_alarm_enable = 11,
33  xroad_object_type_pong = 12,
34  xroad_object_type_currency = 13,
35  xroad_object_type_exchange = 14,
36  xroad_object_type_fix_session = 15,
37  xroad_object_type_order = 16,
38  xroad_object_type_pos = 17,
39  xroad_object_type_order_stat = 18,
40  xroad_object_type_iceberg = 19,
41  xroad_object_type_twap = 20,
42  xroad_object_type_pov = 21,
43  xroad_object_type_vwap = 22,
44  xroad_object_type_instr = 23,
45  xroad_object_type_tick_info = 24,
46  xroad_object_type_timesheet = 25,
47  xroad_object_type_mdstat = 102,
48  xroad_object_type_order_sql = 26,
49  xroad_object_type_cancel_sql = 27,
50  xroad_object_type_replace_sql = 28,
51  xroad_object_type_order_rabbit = 29,
52  xroad_object_type_rake = 30,
53  xroad_object_type_stealth = 31,
54  xroad_object_type_spread = 32,
55  xroad_object_type_leg = 33,
56  xroad_object_type_spread_trade = 34,
57  xroad_object_type_cgate_session = 35,
58  xroad_object_type_cgate_table = 36,
59  xroad_object_type_cgate_order = 37,
60  xroad_object_type_obj_uuid = 38,
61  xroad_object_type_free_form = 39,
62  xroad_object_type_order_fix = 41,
63  xroad_object_type_fix_msg_in = 42,
64  xroad_object_type_fix_msg_out = 43,
65  xroad_object_type_trade_fix = 47,
66  xroad_object_type_lock_by_pid = 48,
67  xroad_object_type_system_role_changed = 49,
68  xroad_object_type_cancel = 50,
69  xroad_object_type_remove = 52,
70  xroad_object_type_replace = 53,
71  xroad_object_type_accepted = 70,
72  xroad_object_type_rejected = 71,
73  xroad_object_type_canceled = 73,
74  xroad_object_type_trade = 74,
75  xroad_object_type_cancel_rejected = 75,
76  xroad_object_type_replace_rejected = 76,
77  xroad_object_type_replaced = 77,
78  xroad_object_type_subscribe = 80,
79  xroad_object_type_unsubscribe = 81,
80  xroad_object_type_update = 83,
81  xroad_object_type_money_limit = 84,
82  xroad_object_type_order_limit = 85,
83  xroad_object_type_security_short = 86,
84  xroad_object_type_client_short = 87,
85  xroad_object_type_opt_mm = 90,
86  xroad_object_type_field = 91,
87  xroad_object_type_prop = 92,
88  xroad_object_type_prop_row = 93,
89  xroad_object_type_mmaker = 94,
90  xroad_object_type_sniper = 95,
91  xroad_object_type_pmaker = 97,
92  xroad_object_type_trd_capt = 98,
93  xroad_object_type_props = 99,
94  xroad_object_type_resolve = 100,
95  xroad_object_type_resolve_ack = 101,
96  xroad_object_type_mdata_subs = 103,
97  xroad_object_type_reload = 104,
98  xroad_object_type_sbe_session = 110,
99  xroad_object_type_order_crypto = 111,
100  xroad_object_type_crypto_session = 112,
101  xroad_object_type_acc_pos = 113,
102  xroad_object_type_acc_balance = 114,
103  xroad_object_type_order_ws = 116,
104  xroad_object_type_order_sbe = 117,
105  xroad_object_type_pmaker_total = 118,
106  xroad_object_type_cancel_all = 119,
107  xroad_object_type_pos_reset = 120,
108  xroad_object_type_acc_int_request = 121,
109  xroad_object_type_acc_int_response = 122,
110  xroad_object_type_fund_asset = 123,
111  xroad_object_type_rps_robot = 124,
112  xroad_object_type_rps_filter = 125,
113  xroad_object_type_fi_bot = 126,
114  xroad_object_type_mdsource = 127,
115  xroad_object_type_instr_mdsource = 128,
116  xroad_object_type_instr_basket = 129,
117  xroad_object_type_broker = 130,
118  xroad_object_type_spbex_bin_session = 131,
119  xroad_object_type_order_spbex = 132,
120  xroad_object_type_scheduled = 133,
121  xroad_object_type_mdconsumer = 134,
122  xroad_object_type_pre_trade = 135,
123  xroad_object_type_pre_trade_ack = 136,
124  xroad_object_type_speedway = 137,
125  xroad_object_type_top_book = 138,
126  xroad_object_type_none = -1
127 } xroad_object_type_t;
128 
129 typedef struct
130 {
131  xroad_object_type_t type;
132  xroad_object_id_t id;
134 
135 typedef enum
136 {
137  xroad_object_storage_type_table = 1,
138  xroad_object_storage_type_heap = 2,
139  xroad_object_storage_type_memory = 3
140 } xroad_object_storage_type_t;
141 
142 typedef int64_t xroad_int64_t;
143 
144 typedef uint64_t xroad_uint64_t;
145 
146 typedef int32_t xroad_int32_t;
147 
148 typedef uint32_t xroad_uint32_t;
149 
150 typedef int8_t xroad_int8_t;
151 
152 typedef double xroad_double_t;
153 
154 typedef bool xroad_bool_t;
155 
159 typedef int64_t xroad_qty_t;
160 
161 typedef double xroad_price_t;
162 
163 typedef int64_t xroad_seqnum_t;
164 
165 typedef int32_t xroad_fix_reason_t;
166 
167 typedef int32_t xroad_sub_status_t;
168 
169 typedef int8_t xroad_is_crashed_t;
170 
171 typedef int32_t xroad_check_req_id_t;
172 
173 typedef int64_t xroad_check_ext_id_t;
174 
175 #define XROAD_CLORD_ID_SIZE 36U
176 xroad_str_decl(xroad_clord_id, XROAD_CLORD_ID_SIZE);
177 
178 #define XROAD_ACCOUNT_SIZE 16U
179 xroad_str_decl(xroad_account, XROAD_ACCOUNT_SIZE);
180 
181 #define XROAD_CLIENT_CODE_SIZE 16U
182 xroad_str_decl(xroad_client_code, XROAD_CLIENT_CODE_SIZE);
183 
187 #define XROAD_NAME_SIZE 64U
188 xroad_str_decl(xroad_name, XROAD_NAME_SIZE);
189 
193 #define XROAD_ALIAS_SIZE 64U
194 xroad_str_decl(xroad_alias, XROAD_ALIAS_SIZE);
195 
199 #define XROAD_CFI_SIZE 6U
200 xroad_str_decl(xroad_cfi, XROAD_CFI_SIZE);
201 
202 #define XROAD_ISIN_SIZE 12U
203 xroad_str_decl(xroad_isin, XROAD_ISIN_SIZE);
204 
205 #define XROAD_BB_CODE_SIZE 32U
206 xroad_str_decl(xroad_bb_code, XROAD_BB_CODE_SIZE);
207 
208 #define XROAD_UUID_SIZE 36U
209 xroad_str_decl(xroad_uuid, XROAD_UUID_SIZE);
210 
211 #define XROAD_EXCH_ID_SIZE 36U
212 xroad_str_decl(xroad_exch_id, XROAD_EXCH_ID_SIZE);
213 
214 #define XROAD_STRING4_SIZE 4U
215 xroad_str_decl(xroad_string4, XROAD_STRING4_SIZE);
216 
217 #define XROAD_STRING8_SIZE 8U
218 xroad_str_decl(xroad_string8, XROAD_STRING8_SIZE);
219 
220 #define XROAD_STRING12_SIZE 12U
221 xroad_str_decl(xroad_string12, XROAD_STRING12_SIZE);
222 
223 #define XROAD_STRING16_SIZE 16U
224 xroad_str_decl(xroad_string16, XROAD_STRING16_SIZE);
225 
226 #define XROAD_STRING32_SIZE 32U
227 xroad_str_decl(xroad_string32, XROAD_STRING32_SIZE);
228 
229 #define XROAD_STRING36_SIZE 36U
230 xroad_str_decl(xroad_string36, XROAD_STRING36_SIZE);
231 
232 #define XROAD_STRING20_SIZE 20U
233 xroad_str_decl(xroad_string20, XROAD_STRING20_SIZE);
234 
235 typedef enum
236 {
237  xroad_domain_order = 1,
238  xroad_domain_mdata = 2,
239  xroad_domain_position = 3,
240  xroad_domain_prop = 4,
241 } xroad_domain_t;
242 
243 typedef enum
244 {
245  xroad_side_undef = '0',
246  xroad_side_buy = '1',
247  xroad_side_sell = '2',
248 } xroad_side_t;
249 
253 typedef enum
254 {
259 
263 typedef enum
264 {
269  xroad_order_flags_close_position = 16,
270  xroad_order_flags_handl_inst_public = 32,
271  xroad_order_flags_handl_inst_private = 64,
272  xroad_order_flags_handl_inst_manual = 128,
273  xroad_order_flags_autodelete = 256,
275  xroad_order_flags_ignore_dyn_limits = 1024,
278  xroad_order_flags_otc = 8192,
279  xroad_order_flags_reinstate_on_fail = 16384,
280  xroad_order_flags_cancel_on_cross = 32768,
281  xroad_order_flags_dont_crossmm = 65536,
282  xroad_order_flags_ignore_mdata = 131072,
288 
289 typedef enum
290 {
291  xroad_tif_day = '0',
292  xroad_tif_GTC = '1',
293  xroad_tif_open = '2',
294  xroad_tif_IOC = '3',
295  xroad_tif_FOK = '4',
296  xroad_tif_GTX = '5',
297  xroad_tif_GTD = '6',
298  xroad_tif_close = '7',
299 } xroad_tif_t;
300 
301 typedef enum
302 {
303  xroad_rej_reason_other = 1,
304  xroad_rej_reason_too_late = 2,
305  xroad_rej_reason_unknown_instr = 3,
306  xroad_rej_reason_duplicate = 4,
307  xroad_rej_reason_exceed_limit = 5,
308  xroad_rej_reason_exch_closed = 6,
309  xroad_rej_reason_broker_opt = 7,
310  xroad_rej_reason_wrong_account = 8,
311  xroad_rej_reason_already_in_pending = 9,
312  xroad_rej_reason_unknown = 10,
313  xroad_rej_reason_internal_error = 11,
314  xroad_rej_reason_tran_limit = 12,
315  xroad_rej_reason_removed = 13,
316  xroad_rej_reason_guard = 14,
317  xroad_rej_reason_exchange = 15,
318  xroad_rej_reason_try_again = 16,
319  xroad_rej_reason_timeout = 17,
320  xroad_rej_reason_wrong_order = 18,
321  xroad_rej_reason_unknown_order = 19,
322  xroad_rej_reason_locked_order = 20,
323  xroad_rej_reason_cross = 21,
324  xroad_rej_reason_cross_book = 22,
325  xroad_rej_reason_routing = 23,
326  xroad_rej_reason_expired = 24,
327 } xroad_rej_reason_t;
328 
329 typedef enum
330 {
331  xroad_alarm_level_error = 1,
332  xroad_alarm_level_warning = 2,
333  xroad_alarm_level_notice = 4,
334 } xroad_alarm_level_t;
335 
336 typedef enum
337 {
338  xroad_order_fix_status_new = '0',
339  xroad_order_fix_status_partially_filled = '1',
340  xroad_order_fix_status_filled = '2',
341  xroad_order_fix_status_canceled = '4',
342  xroad_order_fix_status_pending_cancel = '6',
343  xroad_order_fix_status_rejected = '8',
344  xroad_order_fix_status_pending_new = 'A',
345  xroad_order_fix_status_expired = 'C',
346  xroad_order_fix_status_pending_replace = 'E',
347 } xroad_order_fix_status_t;
348 
349 typedef enum
350 {
351  xroad_order_status_initial = 'I',
352  xroad_order_status_active = 'A',
353  xroad_order_status_filled = 'F',
354  xroad_order_status_canceled = 'C',
355  xroad_order_status_rejected = 'R',
356  xroad_order_status_expired = 'E',
357  xroad_order_status_removed = 'T',
358  xroad_order_status_awaiting_active = 'a',
359  xroad_order_status_awaiting_cancel = 'c',
360  xroad_order_status_awaiting_replace = 'r',
361 } xroad_order_status_t;
362 
363 typedef enum
364 {
365  xroad_exec_type_new = '0',
366  xroad_exec_type_canceled = '4',
367  xroad_exec_type_replace = '5',
368  xroad_exec_type_pending_cancel = '6',
369  xroad_exec_type_rejected = '8',
370  xroad_exec_type_expired = 'C',
371  xroad_exec_type_pending_replace = 'E',
372  xroad_exec_type_trade = 'F',
373 } xroad_exec_type_t;
374 
375 typedef enum
376 {
377  xroad_session_state_disconnected = 0,
378  xroad_session_state_connected = 1,
379  xroad_session_state_awaiting_logon = 2,
380  xroad_session_state_awaiting_logon_ack = 3,
381  xroad_session_state_awaiting_test_ack = 4,
382  xroad_session_state_awaiting_disconnect = 5,
383  xroad_session_state_awaiting_connect = 6,
384 } xroad_session_state_t;
385 
386 typedef enum
387 {
388  xroad_fix_session_status_started = 1,
389  xroad_fix_session_status_finished = 2,
390 } xroad_fix_session_status_t;
391 
392 typedef enum
393 {
394  xroad_rej_response_to_cancel = '1',
395  xroad_rej_response_to_replace = '2',
396 } xroad_rej_response_to_t;
397 
398 typedef enum
399 {
400  xroad_field_type_string = 1,
401  xroad_field_type_integer = 2,
402  xroad_field_type_double = 3,
403  xroad_field_type_time = 4,
404 } xroad_field_type_t;
405 
406 typedef enum
407 {
408  xroad_prop_type_string = 1,
409  xroad_prop_type_boolean = 2,
410  xroad_prop_type_integer = 3,
411  xroad_prop_type_double = 4,
412  xroad_prop_type_time = 5,
413  xroad_prop_type_table = 6,
414 } xroad_prop_type_t;
415 
416 typedef enum
417 {
418  xroad_opt_mm_state_disabled = 0,
419  xroad_opt_mm_state_pending = 1,
420  xroad_opt_mm_state_active = 2,
421  xroad_opt_mm_state_error = 3,
422  xroad_opt_mm_state_filled = 4,
423 } xroad_opt_mm_state_t;
424 
425 typedef enum
426 {
427  xroad_reset_hint_statistic = 1,
428  xroad_reset_hint_fix_session = 2,
429  xroad_reset_hint_state = 4,
430 } xroad_reset_hint_t;
431 
432 typedef enum
433 {
434  xroad_callput_call = 1,
435  xroad_callput_put = 2,
436 } xroad_callput_t;
437 
438 typedef enum
439 {
440  xroad_calc_mid_by_shift = 1,
441  xroad_calc_mid_by_shift_vol = 2,
442 } xroad_calc_mid_t;
443 
444 typedef enum
445 {
446  xroad_mleg_report_type_single = '1',
447  xroad_mleg_report_type_leg = '2',
448  xroad_mleg_report_type_mleg_sec = '3',
449 } xroad_mleg_report_type_t;
450 
451 typedef enum
452 {
453  xroad_subs_result_subscribed = 0,
454  xroad_subs_result_unsubscribed = 1,
455  xroad_subs_result_already_subscribed = 2,
456  xroad_subs_result_instr_not_found = 3,
457  xroad_subs_result_too_many_subscriptions = 4,
458  xroad_subs_result_internal_error = 5,
459  xroad_subs_result_external_error = 6,
460 } xroad_subs_result_t;
461 
462 typedef enum
463 {
464  xroad_mdata_subs_state_unsubscribed = 1,
465  xroad_mdata_subs_state_subscribed = 2,
466  xroad_mdata_subs_state_awaiting_subs = 3,
467  xroad_mdata_subs_state_awaiting_unsubs = 4,
468  xroad_mdata_subs_state_deleted = 5,
469 } xroad_mdata_subs_state_t;
470 
471 typedef enum
472 {
473  xroad_mdsource_state_online = 1,
474  xroad_mdsource_state_recovery = 2,
475  xroad_mdsource_state_offline = 3,
476 } xroad_mdsource_state_t;
477 
478 typedef enum
479 {
483 
484 typedef enum
485 {
486  xroad_auct_status_active = 'A',
487  xroad_auct_status_inactive = 'N',
488  xroad_auct_status_completed = 'H',
489  xroad_auct_status_undefined = 'E',
490 } xroad_auct_status_t;
491 
492 typedef enum
493 {
494  xroad_trading_session_type_opening_auct = 1,
495  xroad_trading_session_type_regular = 2,
496  xroad_trading_session_type_closing_auct = 3,
497  xroad_trading_session_type_after_hours = 4,
498 } xroad_trading_session_type_t;
499 
500 typedef enum
501 {
502  xroad_trading_status_regular_trading = 1,
503  xroad_trading_status_opening_period = 2,
504  xroad_trading_status_closing_period = 3,
505  xroad_trading_status_opening_auction = 4,
506  xroad_trading_status_closing_auction = 5,
507  xroad_trading_status_auction = 6,
508  xroad_trading_status__reserved1 = 7,
509  xroad_trading_status_halt = 8,
510  xroad_trading_status_closed = 9,
511  xroad_trading_status__reserved2 = 10,
512  xroad_trading_status_unknown = 11,
513 } xroad_trading_status_t;
514 
515 typedef enum
516 {
520 
521 typedef enum
522 {
526 
527 typedef enum
528 {
535 
539 typedef enum
540 {
543 
547 typedef enum
548 {
552 
553 
554 //--------------------------------------------------------------------------------------------------------------------//
555 static inline xroad_object_type_t xroad_object_type_from_str(xroad_str_t str)
556 {
557  if (!xroad_str_cmp(xroad_str("start"), str))
558  {
559  return xroad_object_type_start;
560  }
561  if (!xroad_str_cmp(xroad_str("stop"), str))
562  {
563  return xroad_object_type_stop;
564  }
565  if (!xroad_str_cmp(xroad_str("reconfig"), str))
566  {
567  return xroad_object_type_reconfig;
568  }
569  if (!xroad_str_cmp(xroad_str("activate"), str))
570  {
571  return xroad_object_type_activate;
572  }
573  if (!xroad_str_cmp(xroad_str("deactivate"), str))
574  {
575  return xroad_object_type_deactivate;
576  }
577  if (!xroad_str_cmp(xroad_str("date_changed"), str))
578  {
579  return xroad_object_type_date_changed;
580  }
581  if (!xroad_str_cmp(xroad_str("reset"), str))
582  {
583  return xroad_object_type_reset;
584  }
585  if (!xroad_str_cmp(xroad_str("alarm"), str))
586  {
587  return xroad_object_type_alarm;
588  }
589  if (!xroad_str_cmp(xroad_str("node_event"), str))
590  {
591  return xroad_object_type_node_event;
592  }
593  if (!xroad_str_cmp(xroad_str("ping"), str))
594  {
595  return xroad_object_type_ping;
596  }
597  if (!xroad_str_cmp(xroad_str("alarm_enable"), str))
598  {
599  return xroad_object_type_alarm_enable;
600  }
601  if (!xroad_str_cmp(xroad_str("pong"), str))
602  {
603  return xroad_object_type_pong;
604  }
605  if (!xroad_str_cmp(xroad_str("currency"), str))
606  {
607  return xroad_object_type_currency;
608  }
609  if (!xroad_str_cmp(xroad_str("exchange"), str))
610  {
611  return xroad_object_type_exchange;
612  }
613  if (!xroad_str_cmp(xroad_str("fix_session"), str))
614  {
615  return xroad_object_type_fix_session;
616  }
617  if (!xroad_str_cmp(xroad_str("order"), str))
618  {
619  return xroad_object_type_order;
620  }
621  if (!xroad_str_cmp(xroad_str("pos"), str))
622  {
623  return xroad_object_type_pos;
624  }
625  if (!xroad_str_cmp(xroad_str("order_stat"), str))
626  {
627  return xroad_object_type_order_stat;
628  }
629  if (!xroad_str_cmp(xroad_str("iceberg"), str))
630  {
631  return xroad_object_type_iceberg;
632  }
633  if (!xroad_str_cmp(xroad_str("twap"), str))
634  {
635  return xroad_object_type_twap;
636  }
637  if (!xroad_str_cmp(xroad_str("pov"), str))
638  {
639  return xroad_object_type_pov;
640  }
641  if (!xroad_str_cmp(xroad_str("vwap"), str))
642  {
643  return xroad_object_type_vwap;
644  }
645  if (!xroad_str_cmp(xroad_str("instr"), str))
646  {
647  return xroad_object_type_instr;
648  }
649  if (!xroad_str_cmp(xroad_str("tick_info"), str))
650  {
651  return xroad_object_type_tick_info;
652  }
653  if (!xroad_str_cmp(xroad_str("timesheet"), str))
654  {
655  return xroad_object_type_timesheet;
656  }
657  if (!xroad_str_cmp(xroad_str("mdstat"), str))
658  {
659  return xroad_object_type_mdstat;
660  }
661  if (!xroad_str_cmp(xroad_str("order_sql"), str))
662  {
663  return xroad_object_type_order_sql;
664  }
665  if (!xroad_str_cmp(xroad_str("cancel_sql"), str))
666  {
667  return xroad_object_type_cancel_sql;
668  }
669  if (!xroad_str_cmp(xroad_str("replace_sql"), str))
670  {
671  return xroad_object_type_replace_sql;
672  }
673  if (!xroad_str_cmp(xroad_str("order_rabbit"), str))
674  {
675  return xroad_object_type_order_rabbit;
676  }
677  if (!xroad_str_cmp(xroad_str("rake"), str))
678  {
679  return xroad_object_type_rake;
680  }
681  if (!xroad_str_cmp(xroad_str("stealth"), str))
682  {
683  return xroad_object_type_stealth;
684  }
685  if (!xroad_str_cmp(xroad_str("spread"), str))
686  {
687  return xroad_object_type_spread;
688  }
689  if (!xroad_str_cmp(xroad_str("leg"), str))
690  {
691  return xroad_object_type_leg;
692  }
693  if (!xroad_str_cmp(xroad_str("spread_trade"), str))
694  {
695  return xroad_object_type_spread_trade;
696  }
697  if (!xroad_str_cmp(xroad_str("cgate_session"), str))
698  {
699  return xroad_object_type_cgate_session;
700  }
701  if (!xroad_str_cmp(xroad_str("cgate_table"), str))
702  {
703  return xroad_object_type_cgate_table;
704  }
705  if (!xroad_str_cmp(xroad_str("cgate_order"), str))
706  {
707  return xroad_object_type_cgate_order;
708  }
709  if (!xroad_str_cmp(xroad_str("obj_uuid"), str))
710  {
711  return xroad_object_type_obj_uuid;
712  }
713  if (!xroad_str_cmp(xroad_str("free_form"), str))
714  {
715  return xroad_object_type_free_form;
716  }
717  if (!xroad_str_cmp(xroad_str("order_fix"), str))
718  {
719  return xroad_object_type_order_fix;
720  }
721  if (!xroad_str_cmp(xroad_str("fix_msg_in"), str))
722  {
723  return xroad_object_type_fix_msg_in;
724  }
725  if (!xroad_str_cmp(xroad_str("fix_msg_out"), str))
726  {
727  return xroad_object_type_fix_msg_out;
728  }
729  if (!xroad_str_cmp(xroad_str("trade_fix"), str))
730  {
731  return xroad_object_type_trade_fix;
732  }
733  if (!xroad_str_cmp(xroad_str("lock_by_pid"), str))
734  {
735  return xroad_object_type_lock_by_pid;
736  }
737  if (!xroad_str_cmp(xroad_str("system_role_changed"), str))
738  {
739  return xroad_object_type_system_role_changed;
740  }
741  if (!xroad_str_cmp(xroad_str("cancel"), str))
742  {
743  return xroad_object_type_cancel;
744  }
745  if (!xroad_str_cmp(xroad_str("remove"), str))
746  {
747  return xroad_object_type_remove;
748  }
749  if (!xroad_str_cmp(xroad_str("replace"), str))
750  {
751  return xroad_object_type_replace;
752  }
753  if (!xroad_str_cmp(xroad_str("accepted"), str))
754  {
755  return xroad_object_type_accepted;
756  }
757  if (!xroad_str_cmp(xroad_str("rejected"), str))
758  {
759  return xroad_object_type_rejected;
760  }
761  if (!xroad_str_cmp(xroad_str("canceled"), str))
762  {
763  return xroad_object_type_canceled;
764  }
765  if (!xroad_str_cmp(xroad_str("trade"), str))
766  {
767  return xroad_object_type_trade;
768  }
769  if (!xroad_str_cmp(xroad_str("cancel_rejected"), str))
770  {
771  return xroad_object_type_cancel_rejected;
772  }
773  if (!xroad_str_cmp(xroad_str("replace_rejected"), str))
774  {
775  return xroad_object_type_replace_rejected;
776  }
777  if (!xroad_str_cmp(xroad_str("replaced"), str))
778  {
779  return xroad_object_type_replaced;
780  }
781  if (!xroad_str_cmp(xroad_str("subscribe"), str))
782  {
783  return xroad_object_type_subscribe;
784  }
785  if (!xroad_str_cmp(xroad_str("unsubscribe"), str))
786  {
787  return xroad_object_type_unsubscribe;
788  }
789  if (!xroad_str_cmp(xroad_str("update"), str))
790  {
791  return xroad_object_type_update;
792  }
793  if (!xroad_str_cmp(xroad_str("money_limit"), str))
794  {
795  return xroad_object_type_money_limit;
796  }
797  if (!xroad_str_cmp(xroad_str("order_limit"), str))
798  {
799  return xroad_object_type_order_limit;
800  }
801  if (!xroad_str_cmp(xroad_str("security_short"), str))
802  {
803  return xroad_object_type_security_short;
804  }
805  if (!xroad_str_cmp(xroad_str("client_short"), str))
806  {
807  return xroad_object_type_client_short;
808  }
809  if (!xroad_str_cmp(xroad_str("opt_mm"), str))
810  {
811  return xroad_object_type_opt_mm;
812  }
813  if (!xroad_str_cmp(xroad_str("field"), str))
814  {
815  return xroad_object_type_field;
816  }
817  if (!xroad_str_cmp(xroad_str("prop"), str))
818  {
819  return xroad_object_type_prop;
820  }
821  if (!xroad_str_cmp(xroad_str("prop_row"), str))
822  {
823  return xroad_object_type_prop_row;
824  }
825  if (!xroad_str_cmp(xroad_str("mmaker"), str))
826  {
827  return xroad_object_type_mmaker;
828  }
829  if (!xroad_str_cmp(xroad_str("sniper"), str))
830  {
831  return xroad_object_type_sniper;
832  }
833  if (!xroad_str_cmp(xroad_str("pmaker"), str))
834  {
835  return xroad_object_type_pmaker;
836  }
837  if (!xroad_str_cmp(xroad_str("trd_capt"), str))
838  {
839  return xroad_object_type_trd_capt;
840  }
841  if (!xroad_str_cmp(xroad_str("props"), str))
842  {
843  return xroad_object_type_props;
844  }
845  if (!xroad_str_cmp(xroad_str("resolve"), str))
846  {
847  return xroad_object_type_resolve;
848  }
849  if (!xroad_str_cmp(xroad_str("resolve_ack"), str))
850  {
851  return xroad_object_type_resolve_ack;
852  }
853  if (!xroad_str_cmp(xroad_str("mdata_subs"), str))
854  {
855  return xroad_object_type_mdata_subs;
856  }
857  if (!xroad_str_cmp(xroad_str("reload"), str))
858  {
859  return xroad_object_type_reload;
860  }
861  if (!xroad_str_cmp(xroad_str("sbe_session"), str))
862  {
863  return xroad_object_type_sbe_session;
864  }
865  if (!xroad_str_cmp(xroad_str("order_crypto"), str))
866  {
867  return xroad_object_type_order_crypto;
868  }
869  if (!xroad_str_cmp(xroad_str("crypto_session"), str))
870  {
871  return xroad_object_type_crypto_session;
872  }
873  if (!xroad_str_cmp(xroad_str("acc_pos"), str))
874  {
875  return xroad_object_type_acc_pos;
876  }
877  if (!xroad_str_cmp(xroad_str("acc_balance"), str))
878  {
879  return xroad_object_type_acc_balance;
880  }
881  if (!xroad_str_cmp(xroad_str("order_ws"), str))
882  {
883  return xroad_object_type_order_ws;
884  }
885  if (!xroad_str_cmp(xroad_str("order_sbe"), str))
886  {
887  return xroad_object_type_order_sbe;
888  }
889  if (!xroad_str_cmp(xroad_str("pmaker_total"), str))
890  {
891  return xroad_object_type_pmaker_total;
892  }
893  if (!xroad_str_cmp(xroad_str("cancel_all"), str))
894  {
895  return xroad_object_type_cancel_all;
896  }
897  if (!xroad_str_cmp(xroad_str("pos_reset"), str))
898  {
899  return xroad_object_type_pos_reset;
900  }
901  if (!xroad_str_cmp(xroad_str("acc_int_request"), str))
902  {
903  return xroad_object_type_acc_int_request;
904  }
905  if (!xroad_str_cmp(xroad_str("acc_int_response"), str))
906  {
907  return xroad_object_type_acc_int_response;
908  }
909  if (!xroad_str_cmp(xroad_str("fund_asset"), str))
910  {
911  return xroad_object_type_fund_asset;
912  }
913  if (!xroad_str_cmp(xroad_str("rps_robot"), str))
914  {
915  return xroad_object_type_rps_robot;
916  }
917  if (!xroad_str_cmp(xroad_str("rps_filter"), str))
918  {
919  return xroad_object_type_rps_filter;
920  }
921  if (!xroad_str_cmp(xroad_str("fi_bot"), str))
922  {
923  return xroad_object_type_fi_bot;
924  }
925  if (!xroad_str_cmp(xroad_str("mdsource"), str))
926  {
927  return xroad_object_type_mdsource;
928  }
929  if (!xroad_str_cmp(xroad_str("instr_mdsource"), str))
930  {
931  return xroad_object_type_instr_mdsource;
932  }
933  if (!xroad_str_cmp(xroad_str("instr_basket"), str))
934  {
935  return xroad_object_type_instr_basket;
936  }
937  if (!xroad_str_cmp(xroad_str("broker"), str))
938  {
939  return xroad_object_type_broker;
940  }
941  if (!xroad_str_cmp(xroad_str("spbex_bin_session"), str))
942  {
943  return xroad_object_type_spbex_bin_session;
944  }
945  if (!xroad_str_cmp(xroad_str("order_spbex"), str))
946  {
947  return xroad_object_type_order_spbex;
948  }
949  if (!xroad_str_cmp(xroad_str("scheduled"), str))
950  {
951  return xroad_object_type_scheduled;
952  }
953  if (!xroad_str_cmp(xroad_str("mdconsumer"), str))
954  {
955  return xroad_object_type_mdconsumer;
956  }
957  if (!xroad_str_cmp(xroad_str("pre_trade"), str))
958  {
959  return xroad_object_type_pre_trade;
960  }
961  if (!xroad_str_cmp(xroad_str("pre_trade_ack"), str))
962  {
963  return xroad_object_type_pre_trade_ack;
964  }
965  if (!xroad_str_cmp(xroad_str("speedway"), str))
966  {
967  return xroad_object_type_speedway;
968  }
969  if (!xroad_str_cmp(xroad_str("top_book"), str))
970  {
971  return xroad_object_type_top_book;
972  }
973  return xroad_object_type_none;
974 }
975 
976 //--------------------------------------------------------------------------------------------------------------------//
977 static inline xroad_str_t xroad_object_type_to_str(xroad_object_type_t type)
978 {
979  switch(type)
980  {
981  case xroad_object_type_start:
982  {
983  return xroad_str("start");
984  }
985  case xroad_object_type_stop:
986  {
987  return xroad_str("stop");
988  }
989  case xroad_object_type_reconfig:
990  {
991  return xroad_str("reconfig");
992  }
993  case xroad_object_type_activate:
994  {
995  return xroad_str("activate");
996  }
997  case xroad_object_type_deactivate:
998  {
999  return xroad_str("deactivate");
1000  }
1001  case xroad_object_type_date_changed:
1002  {
1003  return xroad_str("date_changed");
1004  }
1005  case xroad_object_type_reset:
1006  {
1007  return xroad_str("reset");
1008  }
1009  case xroad_object_type_alarm:
1010  {
1011  return xroad_str("alarm");
1012  }
1013  case xroad_object_type_node_event:
1014  {
1015  return xroad_str("node_event");
1016  }
1017  case xroad_object_type_ping:
1018  {
1019  return xroad_str("ping");
1020  }
1021  case xroad_object_type_alarm_enable:
1022  {
1023  return xroad_str("alarm_enable");
1024  }
1025  case xroad_object_type_pong:
1026  {
1027  return xroad_str("pong");
1028  }
1029  case xroad_object_type_currency:
1030  {
1031  return xroad_str("currency");
1032  }
1033  case xroad_object_type_exchange:
1034  {
1035  return xroad_str("exchange");
1036  }
1037  case xroad_object_type_fix_session:
1038  {
1039  return xroad_str("fix_session");
1040  }
1041  case xroad_object_type_order:
1042  {
1043  return xroad_str("order");
1044  }
1045  case xroad_object_type_pos:
1046  {
1047  return xroad_str("pos");
1048  }
1049  case xroad_object_type_order_stat:
1050  {
1051  return xroad_str("order_stat");
1052  }
1053  case xroad_object_type_iceberg:
1054  {
1055  return xroad_str("iceberg");
1056  }
1057  case xroad_object_type_twap:
1058  {
1059  return xroad_str("twap");
1060  }
1061  case xroad_object_type_pov:
1062  {
1063  return xroad_str("pov");
1064  }
1065  case xroad_object_type_vwap:
1066  {
1067  return xroad_str("vwap");
1068  }
1069  case xroad_object_type_instr:
1070  {
1071  return xroad_str("instr");
1072  }
1073  case xroad_object_type_tick_info:
1074  {
1075  return xroad_str("tick_info");
1076  }
1077  case xroad_object_type_timesheet:
1078  {
1079  return xroad_str("timesheet");
1080  }
1081  case xroad_object_type_mdstat:
1082  {
1083  return xroad_str("mdstat");
1084  }
1085  case xroad_object_type_order_sql:
1086  {
1087  return xroad_str("order_sql");
1088  }
1089  case xroad_object_type_cancel_sql:
1090  {
1091  return xroad_str("cancel_sql");
1092  }
1093  case xroad_object_type_replace_sql:
1094  {
1095  return xroad_str("replace_sql");
1096  }
1097  case xroad_object_type_order_rabbit:
1098  {
1099  return xroad_str("order_rabbit");
1100  }
1101  case xroad_object_type_rake:
1102  {
1103  return xroad_str("rake");
1104  }
1105  case xroad_object_type_stealth:
1106  {
1107  return xroad_str("stealth");
1108  }
1109  case xroad_object_type_spread:
1110  {
1111  return xroad_str("spread");
1112  }
1113  case xroad_object_type_leg:
1114  {
1115  return xroad_str("leg");
1116  }
1117  case xroad_object_type_spread_trade:
1118  {
1119  return xroad_str("spread_trade");
1120  }
1121  case xroad_object_type_cgate_session:
1122  {
1123  return xroad_str("cgate_session");
1124  }
1125  case xroad_object_type_cgate_table:
1126  {
1127  return xroad_str("cgate_table");
1128  }
1129  case xroad_object_type_cgate_order:
1130  {
1131  return xroad_str("cgate_order");
1132  }
1133  case xroad_object_type_obj_uuid:
1134  {
1135  return xroad_str("obj_uuid");
1136  }
1137  case xroad_object_type_free_form:
1138  {
1139  return xroad_str("free_form");
1140  }
1141  case xroad_object_type_order_fix:
1142  {
1143  return xroad_str("order_fix");
1144  }
1145  case xroad_object_type_fix_msg_in:
1146  {
1147  return xroad_str("fix_msg_in");
1148  }
1149  case xroad_object_type_fix_msg_out:
1150  {
1151  return xroad_str("fix_msg_out");
1152  }
1153  case xroad_object_type_trade_fix:
1154  {
1155  return xroad_str("trade_fix");
1156  }
1157  case xroad_object_type_lock_by_pid:
1158  {
1159  return xroad_str("lock_by_pid");
1160  }
1161  case xroad_object_type_system_role_changed:
1162  {
1163  return xroad_str("system_role_changed");
1164  }
1165  case xroad_object_type_cancel:
1166  {
1167  return xroad_str("cancel");
1168  }
1169  case xroad_object_type_remove:
1170  {
1171  return xroad_str("remove");
1172  }
1173  case xroad_object_type_replace:
1174  {
1175  return xroad_str("replace");
1176  }
1177  case xroad_object_type_accepted:
1178  {
1179  return xroad_str("accepted");
1180  }
1181  case xroad_object_type_rejected:
1182  {
1183  return xroad_str("rejected");
1184  }
1185  case xroad_object_type_canceled:
1186  {
1187  return xroad_str("canceled");
1188  }
1189  case xroad_object_type_trade:
1190  {
1191  return xroad_str("trade");
1192  }
1193  case xroad_object_type_cancel_rejected:
1194  {
1195  return xroad_str("cancel_rejected");
1196  }
1197  case xroad_object_type_replace_rejected:
1198  {
1199  return xroad_str("replace_rejected");
1200  }
1201  case xroad_object_type_replaced:
1202  {
1203  return xroad_str("replaced");
1204  }
1205  case xroad_object_type_subscribe:
1206  {
1207  return xroad_str("subscribe");
1208  }
1209  case xroad_object_type_unsubscribe:
1210  {
1211  return xroad_str("unsubscribe");
1212  }
1213  case xroad_object_type_update:
1214  {
1215  return xroad_str("update");
1216  }
1217  case xroad_object_type_money_limit:
1218  {
1219  return xroad_str("money_limit");
1220  }
1221  case xroad_object_type_order_limit:
1222  {
1223  return xroad_str("order_limit");
1224  }
1225  case xroad_object_type_security_short:
1226  {
1227  return xroad_str("security_short");
1228  }
1229  case xroad_object_type_client_short:
1230  {
1231  return xroad_str("client_short");
1232  }
1233  case xroad_object_type_opt_mm:
1234  {
1235  return xroad_str("opt_mm");
1236  }
1237  case xroad_object_type_field:
1238  {
1239  return xroad_str("field");
1240  }
1241  case xroad_object_type_prop:
1242  {
1243  return xroad_str("prop");
1244  }
1245  case xroad_object_type_prop_row:
1246  {
1247  return xroad_str("prop_row");
1248  }
1249  case xroad_object_type_mmaker:
1250  {
1251  return xroad_str("mmaker");
1252  }
1253  case xroad_object_type_sniper:
1254  {
1255  return xroad_str("sniper");
1256  }
1257  case xroad_object_type_pmaker:
1258  {
1259  return xroad_str("pmaker");
1260  }
1261  case xroad_object_type_trd_capt:
1262  {
1263  return xroad_str("trd_capt");
1264  }
1265  case xroad_object_type_props:
1266  {
1267  return xroad_str("props");
1268  }
1269  case xroad_object_type_resolve:
1270  {
1271  return xroad_str("resolve");
1272  }
1273  case xroad_object_type_resolve_ack:
1274  {
1275  return xroad_str("resolve_ack");
1276  }
1277  case xroad_object_type_mdata_subs:
1278  {
1279  return xroad_str("mdata_subs");
1280  }
1281  case xroad_object_type_reload:
1282  {
1283  return xroad_str("reload");
1284  }
1285  case xroad_object_type_sbe_session:
1286  {
1287  return xroad_str("sbe_session");
1288  }
1289  case xroad_object_type_order_crypto:
1290  {
1291  return xroad_str("order_crypto");
1292  }
1293  case xroad_object_type_crypto_session:
1294  {
1295  return xroad_str("crypto_session");
1296  }
1297  case xroad_object_type_acc_pos:
1298  {
1299  return xroad_str("acc_pos");
1300  }
1301  case xroad_object_type_acc_balance:
1302  {
1303  return xroad_str("acc_balance");
1304  }
1305  case xroad_object_type_order_ws:
1306  {
1307  return xroad_str("order_ws");
1308  }
1309  case xroad_object_type_order_sbe:
1310  {
1311  return xroad_str("order_sbe");
1312  }
1313  case xroad_object_type_pmaker_total:
1314  {
1315  return xroad_str("pmaker_total");
1316  }
1317  case xroad_object_type_cancel_all:
1318  {
1319  return xroad_str("cancel_all");
1320  }
1321  case xroad_object_type_pos_reset:
1322  {
1323  return xroad_str("pos_reset");
1324  }
1325  case xroad_object_type_acc_int_request:
1326  {
1327  return xroad_str("acc_int_request");
1328  }
1329  case xroad_object_type_acc_int_response:
1330  {
1331  return xroad_str("acc_int_response");
1332  }
1333  case xroad_object_type_fund_asset:
1334  {
1335  return xroad_str("fund_asset");
1336  }
1337  case xroad_object_type_rps_robot:
1338  {
1339  return xroad_str("rps_robot");
1340  }
1341  case xroad_object_type_rps_filter:
1342  {
1343  return xroad_str("rps_filter");
1344  }
1345  case xroad_object_type_fi_bot:
1346  {
1347  return xroad_str("fi_bot");
1348  }
1349  case xroad_object_type_mdsource:
1350  {
1351  return xroad_str("mdsource");
1352  }
1353  case xroad_object_type_instr_mdsource:
1354  {
1355  return xroad_str("instr_mdsource");
1356  }
1357  case xroad_object_type_instr_basket:
1358  {
1359  return xroad_str("instr_basket");
1360  }
1361  case xroad_object_type_broker:
1362  {
1363  return xroad_str("broker");
1364  }
1365  case xroad_object_type_spbex_bin_session:
1366  {
1367  return xroad_str("spbex_bin_session");
1368  }
1369  case xroad_object_type_order_spbex:
1370  {
1371  return xroad_str("order_spbex");
1372  }
1373  case xroad_object_type_scheduled:
1374  {
1375  return xroad_str("scheduled");
1376  }
1377  case xroad_object_type_mdconsumer:
1378  {
1379  return xroad_str("mdconsumer");
1380  }
1381  case xroad_object_type_pre_trade:
1382  {
1383  return xroad_str("pre_trade");
1384  }
1385  case xroad_object_type_pre_trade_ack:
1386  {
1387  return xroad_str("pre_trade_ack");
1388  }
1389  case xroad_object_type_speedway:
1390  {
1391  return xroad_str("speedway");
1392  }
1393  case xroad_object_type_top_book:
1394  {
1395  return xroad_str("top_book");
1396  }
1397  default:
1398  {
1399  return xroad_str("none");
1400  }
1401  }
1402 }
1403 
1404 //--------------------------------------------------------------------------------------------------------------------//
1405 static inline xroad_str_t xroad_domain_to_str(xroad_domain_t val)
1406 {
1407  switch(val)
1408  {
1409  case xroad_domain_order:
1410  {
1411  return xroad_str("order");
1412  }
1413  case xroad_domain_mdata:
1414  {
1415  return xroad_str("mdata");
1416  }
1417  case xroad_domain_position:
1418  {
1419  return xroad_str("position");
1420  }
1421  case xroad_domain_prop:
1422  {
1423  return xroad_str("prop");
1424  }
1425  default:
1426  {
1427  return xroad_str_null;
1428  }
1429  }
1430 }
1431 
1432 //--------------------------------------------------------------------------------------------------------------------//
1433 static inline xroad_domain_t xroad_domain_from_str(xroad_str_t val)
1434 {
1435  if (!xroad_str_cmp(val, xroad_str("order")))
1436  {
1437  return xroad_domain_order;
1438  }
1439  if (!xroad_str_cmp(val, xroad_str("mdata")))
1440  {
1441  return xroad_domain_mdata;
1442  }
1443  if (!xroad_str_cmp(val, xroad_str("position")))
1444  {
1445  return xroad_domain_position;
1446  }
1447  if (!xroad_str_cmp(val, xroad_str("prop")))
1448  {
1449  return xroad_domain_prop;
1450  }
1451  return (xroad_domain_t)0;
1452 }
1453 
1454 //--------------------------------------------------------------------------------------------------------------------//
1455 static inline xroad_str_t xroad_domain_get_text(xroad_domain_t val)
1456 {
1457  switch(val)
1458  {
1459  case xroad_domain_order:
1460  {
1461  return xroad_str("order");
1462  }
1463  case xroad_domain_mdata:
1464  {
1465  return xroad_str("mdata");
1466  }
1467  case xroad_domain_position:
1468  {
1469  return xroad_str("position");
1470  }
1471  case xroad_domain_prop:
1472  {
1473  return xroad_str("prop");
1474  }
1475  default:
1476  {
1477  return xroad_str_null;
1478  }
1479  }
1480 }
1481 
1482 //--------------------------------------------------------------------------------------------------------------------//
1483 static inline xroad_str_t xroad_side_to_str(xroad_side_t val)
1484 {
1485  switch(val)
1486  {
1487  case xroad_side_undef:
1488  {
1489  return xroad_str("undef");
1490  }
1491  case xroad_side_buy:
1492  {
1493  return xroad_str("buy");
1494  }
1495  case xroad_side_sell:
1496  {
1497  return xroad_str("sell");
1498  }
1499  default:
1500  {
1501  return xroad_str_null;
1502  }
1503  }
1504 }
1505 
1506 //--------------------------------------------------------------------------------------------------------------------//
1507 static inline xroad_side_t xroad_side_from_str(xroad_str_t val)
1508 {
1509  if (!xroad_str_cmp(val, xroad_str("undef")))
1510  {
1511  return xroad_side_undef;
1512  }
1513  if (!xroad_str_cmp(val, xroad_str("buy")))
1514  {
1515  return xroad_side_buy;
1516  }
1517  if (!xroad_str_cmp(val, xroad_str("sell")))
1518  {
1519  return xroad_side_sell;
1520  }
1521  return (xroad_side_t)0;
1522 }
1523 
1524 //--------------------------------------------------------------------------------------------------------------------//
1525 static inline xroad_str_t xroad_side_get_text(xroad_side_t val)
1526 {
1527  switch(val)
1528  {
1529  case xroad_side_undef:
1530  {
1531  return xroad_str("undef");
1532  }
1533  case xroad_side_buy:
1534  {
1535  return xroad_str("buy");
1536  }
1537  case xroad_side_sell:
1538  {
1539  return xroad_str("sell");
1540  }
1541  default:
1542  {
1543  return xroad_str_null;
1544  }
1545  }
1546 }
1547 
1548 //--------------------------------------------------------------------------------------------------------------------//
1549 static inline xroad_str_t xroad_ord_type_to_str(xroad_ord_type_t val)
1550 {
1551  switch(val)
1552  {
1553  case xroad_ord_type_market:
1554  {
1555  return xroad_str("market");
1556  }
1557  case xroad_ord_type_limit:
1558  {
1559  return xroad_str("limit");
1560  }
1562  {
1563  return xroad_str("stop_limit");
1564  }
1565  default:
1566  {
1567  return xroad_str_null;
1568  }
1569  }
1570 }
1571 
1572 //--------------------------------------------------------------------------------------------------------------------//
1573 static inline xroad_ord_type_t xroad_ord_type_from_str(xroad_str_t val)
1574 {
1575  if (!xroad_str_cmp(val, xroad_str("market")))
1576  {
1577  return xroad_ord_type_market;
1578  }
1579  if (!xroad_str_cmp(val, xroad_str("limit")))
1580  {
1581  return xroad_ord_type_limit;
1582  }
1583  if (!xroad_str_cmp(val, xroad_str("stop_limit")))
1584  {
1586  }
1587  return (xroad_ord_type_t)0;
1588 }
1589 
1590 //--------------------------------------------------------------------------------------------------------------------//
1591 static inline xroad_str_t xroad_ord_type_get_text(xroad_ord_type_t val)
1592 {
1593  switch(val)
1594  {
1595  case xroad_ord_type_market:
1596  {
1597  return xroad_str("market");
1598  }
1599  case xroad_ord_type_limit:
1600  {
1601  return xroad_str("limit");
1602  }
1604  {
1605  return xroad_str("stop limit");
1606  }
1607  default:
1608  {
1609  return xroad_str_null;
1610  }
1611  }
1612 }
1613 
1614 //--------------------------------------------------------------------------------------------------------------------//
1615 static inline xroad_str_t xroad_order_flags_to_str(xroad_order_flags_t val)
1616 {
1617  switch(val)
1618  {
1620  {
1621  return xroad_str("from_mmaker");
1622  }
1624  {
1625  return xroad_str("participate_only");
1626  }
1628  {
1629  return xroad_str("one_triggers_other");
1630  }
1632  {
1633  return xroad_str("all_or_none");
1634  }
1635  case xroad_order_flags_close_position:
1636  {
1637  return xroad_str("close_position");
1638  }
1639  case xroad_order_flags_handl_inst_public:
1640  {
1641  return xroad_str("handl_inst_public");
1642  }
1643  case xroad_order_flags_handl_inst_private:
1644  {
1645  return xroad_str("handl_inst_private");
1646  }
1647  case xroad_order_flags_handl_inst_manual:
1648  {
1649  return xroad_str("handl_inst_manual");
1650  }
1651  case xroad_order_flags_autodelete:
1652  {
1653  return xroad_str("autodelete");
1654  }
1656  {
1657  return xroad_str("warm_up");
1658  }
1659  case xroad_order_flags_ignore_dyn_limits:
1660  {
1661  return xroad_str("ignore_dyn_limits");
1662  }
1664  {
1665  return xroad_str("test");
1666  }
1668  {
1669  return xroad_str("reduce_only");
1670  }
1671  case xroad_order_flags_otc:
1672  {
1673  return xroad_str("otc");
1674  }
1675  case xroad_order_flags_reinstate_on_fail:
1676  {
1677  return xroad_str("reinstate_on_fail");
1678  }
1679  case xroad_order_flags_cancel_on_cross:
1680  {
1681  return xroad_str("cancel_on_cross");
1682  }
1683  case xroad_order_flags_dont_crossmm:
1684  {
1685  return xroad_str("dont_crossmm");
1686  }
1687  case xroad_order_flags_ignore_mdata:
1688  {
1689  return xroad_str("ignore_mdata");
1690  }
1692  {
1693  return xroad_str("quote");
1694  }
1696  {
1697  return xroad_str("transit");
1698  }
1700  {
1701  return xroad_str("parent");
1702  }
1704  {
1705  return xroad_str("manual");
1706  }
1707  default:
1708  {
1709  return xroad_str_null;
1710  }
1711  }
1712 }
1713 
1714 //--------------------------------------------------------------------------------------------------------------------//
1715 static inline xroad_order_flags_t xroad_order_flags_from_str(xroad_str_t val)
1716 {
1717  if (!xroad_str_cmp(val, xroad_str("from_mmaker")))
1718  {
1720  }
1721  if (!xroad_str_cmp(val, xroad_str("participate_only")))
1722  {
1724  }
1725  if (!xroad_str_cmp(val, xroad_str("one_triggers_other")))
1726  {
1728  }
1729  if (!xroad_str_cmp(val, xroad_str("all_or_none")))
1730  {
1732  }
1733  if (!xroad_str_cmp(val, xroad_str("close_position")))
1734  {
1735  return xroad_order_flags_close_position;
1736  }
1737  if (!xroad_str_cmp(val, xroad_str("handl_inst_public")))
1738  {
1739  return xroad_order_flags_handl_inst_public;
1740  }
1741  if (!xroad_str_cmp(val, xroad_str("handl_inst_private")))
1742  {
1743  return xroad_order_flags_handl_inst_private;
1744  }
1745  if (!xroad_str_cmp(val, xroad_str("handl_inst_manual")))
1746  {
1747  return xroad_order_flags_handl_inst_manual;
1748  }
1749  if (!xroad_str_cmp(val, xroad_str("autodelete")))
1750  {
1751  return xroad_order_flags_autodelete;
1752  }
1753  if (!xroad_str_cmp(val, xroad_str("warm_up")))
1754  {
1756  }
1757  if (!xroad_str_cmp(val, xroad_str("ignore_dyn_limits")))
1758  {
1759  return xroad_order_flags_ignore_dyn_limits;
1760  }
1761  if (!xroad_str_cmp(val, xroad_str("test")))
1762  {
1763  return xroad_order_flags_test;
1764  }
1765  if (!xroad_str_cmp(val, xroad_str("reduce_only")))
1766  {
1768  }
1769  if (!xroad_str_cmp(val, xroad_str("otc")))
1770  {
1771  return xroad_order_flags_otc;
1772  }
1773  if (!xroad_str_cmp(val, xroad_str("reinstate_on_fail")))
1774  {
1775  return xroad_order_flags_reinstate_on_fail;
1776  }
1777  if (!xroad_str_cmp(val, xroad_str("cancel_on_cross")))
1778  {
1779  return xroad_order_flags_cancel_on_cross;
1780  }
1781  if (!xroad_str_cmp(val, xroad_str("dont_crossmm")))
1782  {
1783  return xroad_order_flags_dont_crossmm;
1784  }
1785  if (!xroad_str_cmp(val, xroad_str("ignore_mdata")))
1786  {
1787  return xroad_order_flags_ignore_mdata;
1788  }
1789  if (!xroad_str_cmp(val, xroad_str("quote")))
1790  {
1791  return xroad_order_flags_quote;
1792  }
1793  if (!xroad_str_cmp(val, xroad_str("transit")))
1794  {
1796  }
1797  if (!xroad_str_cmp(val, xroad_str("parent")))
1798  {
1799  return xroad_order_flags_parent;
1800  }
1801  if (!xroad_str_cmp(val, xroad_str("manual")))
1802  {
1803  return xroad_order_flags_manual;
1804  }
1805  return (xroad_order_flags_t)0;
1806 }
1807 
1808 //--------------------------------------------------------------------------------------------------------------------//
1809 static inline xroad_str_t xroad_order_flags_get_text(xroad_order_flags_t val)
1810 {
1811  switch(val)
1812  {
1814  {
1815  return xroad_str("from mmaker");
1816  }
1818  {
1819  return xroad_str("participate only");
1820  }
1822  {
1823  return xroad_str("one triggers other");
1824  }
1826  {
1827  return xroad_str("all or none");
1828  }
1829  case xroad_order_flags_close_position:
1830  {
1831  return xroad_str("close position");
1832  }
1833  case xroad_order_flags_handl_inst_public:
1834  {
1835  return xroad_str("automated public");
1836  }
1837  case xroad_order_flags_handl_inst_private:
1838  {
1839  return xroad_str("automated private");
1840  }
1841  case xroad_order_flags_handl_inst_manual:
1842  {
1843  return xroad_str("manual");
1844  }
1845  case xroad_order_flags_autodelete:
1846  {
1847  return xroad_str("autodelete");
1848  }
1850  {
1851  return xroad_str("warm up");
1852  }
1853  case xroad_order_flags_ignore_dyn_limits:
1854  {
1855  return xroad_str("ignore dynamic limits");
1856  }
1858  {
1859  return xroad_str("test");
1860  }
1862  {
1863  return xroad_str("reduce only");
1864  }
1865  case xroad_order_flags_otc:
1866  {
1867  return xroad_str("OTC order. for crossing execution only");
1868  }
1869  case xroad_order_flags_reinstate_on_fail:
1870  {
1871  return xroad_str("reinstate order after system fail");
1872  }
1873  case xroad_order_flags_cancel_on_cross:
1874  {
1875  return xroad_str("cancel order on cross");
1876  }
1877  case xroad_order_flags_dont_crossmm:
1878  {
1879  return xroad_str("do not cross mm");
1880  }
1881  case xroad_order_flags_ignore_mdata:
1882  {
1883  return xroad_str("ignore market data for cross");
1884  }
1886  {
1887  return xroad_str("is quote");
1888  }
1890  {
1891  return xroad_str("transit");
1892  }
1894  {
1895  return xroad_str("is parent");
1896  }
1898  {
1899  return xroad_str("manual placed");
1900  }
1901  default:
1902  {
1903  return xroad_str_null;
1904  }
1905  }
1906 }
1907 
1908 //--------------------------------------------------------------------------------------------------------------------//
1909 static inline xroad_str_t xroad_tif_to_str(xroad_tif_t val)
1910 {
1911  switch(val)
1912  {
1913  case xroad_tif_day:
1914  {
1915  return xroad_str("day");
1916  }
1917  case xroad_tif_GTC:
1918  {
1919  return xroad_str("GTC");
1920  }
1921  case xroad_tif_open:
1922  {
1923  return xroad_str("open");
1924  }
1925  case xroad_tif_IOC:
1926  {
1927  return xroad_str("IOC");
1928  }
1929  case xroad_tif_FOK:
1930  {
1931  return xroad_str("FOK");
1932  }
1933  case xroad_tif_GTX:
1934  {
1935  return xroad_str("GTX");
1936  }
1937  case xroad_tif_GTD:
1938  {
1939  return xroad_str("GTD");
1940  }
1941  case xroad_tif_close:
1942  {
1943  return xroad_str("close");
1944  }
1945  default:
1946  {
1947  return xroad_str_null;
1948  }
1949  }
1950 }
1951 
1952 //--------------------------------------------------------------------------------------------------------------------//
1953 static inline xroad_tif_t xroad_tif_from_str(xroad_str_t val)
1954 {
1955  if (!xroad_str_cmp(val, xroad_str("day")))
1956  {
1957  return xroad_tif_day;
1958  }
1959  if (!xroad_str_cmp(val, xroad_str("GTC")))
1960  {
1961  return xroad_tif_GTC;
1962  }
1963  if (!xroad_str_cmp(val, xroad_str("open")))
1964  {
1965  return xroad_tif_open;
1966  }
1967  if (!xroad_str_cmp(val, xroad_str("IOC")))
1968  {
1969  return xroad_tif_IOC;
1970  }
1971  if (!xroad_str_cmp(val, xroad_str("FOK")))
1972  {
1973  return xroad_tif_FOK;
1974  }
1975  if (!xroad_str_cmp(val, xroad_str("GTX")))
1976  {
1977  return xroad_tif_GTX;
1978  }
1979  if (!xroad_str_cmp(val, xroad_str("GTD")))
1980  {
1981  return xroad_tif_GTD;
1982  }
1983  if (!xroad_str_cmp(val, xroad_str("close")))
1984  {
1985  return xroad_tif_close;
1986  }
1987  return (xroad_tif_t)0;
1988 }
1989 
1990 //--------------------------------------------------------------------------------------------------------------------//
1991 static inline xroad_str_t xroad_tif_get_text(xroad_tif_t val)
1992 {
1993  switch(val)
1994  {
1995  case xroad_tif_day:
1996  {
1997  return xroad_str("day");
1998  }
1999  case xroad_tif_GTC:
2000  {
2001  return xroad_str("GTC");
2002  }
2003  case xroad_tif_open:
2004  {
2005  return xroad_str("open");
2006  }
2007  case xroad_tif_IOC:
2008  {
2009  return xroad_str("IOC");
2010  }
2011  case xroad_tif_FOK:
2012  {
2013  return xroad_str("FOK");
2014  }
2015  case xroad_tif_GTX:
2016  {
2017  return xroad_str("GTX");
2018  }
2019  case xroad_tif_GTD:
2020  {
2021  return xroad_str("GTD");
2022  }
2023  case xroad_tif_close:
2024  {
2025  return xroad_str("close");
2026  }
2027  default:
2028  {
2029  return xroad_str_null;
2030  }
2031  }
2032 }
2033 
2034 //--------------------------------------------------------------------------------------------------------------------//
2035 static inline xroad_str_t xroad_rej_reason_to_str(xroad_rej_reason_t val)
2036 {
2037  switch(val)
2038  {
2039  case xroad_rej_reason_other:
2040  {
2041  return xroad_str("other");
2042  }
2043  case xroad_rej_reason_too_late:
2044  {
2045  return xroad_str("too_late");
2046  }
2047  case xroad_rej_reason_unknown_instr:
2048  {
2049  return xroad_str("unknown_instr");
2050  }
2051  case xroad_rej_reason_duplicate:
2052  {
2053  return xroad_str("duplicate");
2054  }
2055  case xroad_rej_reason_exceed_limit:
2056  {
2057  return xroad_str("exceed_limit");
2058  }
2059  case xroad_rej_reason_exch_closed:
2060  {
2061  return xroad_str("exch_closed");
2062  }
2063  case xroad_rej_reason_broker_opt:
2064  {
2065  return xroad_str("broker_opt");
2066  }
2067  case xroad_rej_reason_wrong_account:
2068  {
2069  return xroad_str("wrong_account");
2070  }
2071  case xroad_rej_reason_already_in_pending:
2072  {
2073  return xroad_str("already_in_pending");
2074  }
2075  case xroad_rej_reason_unknown:
2076  {
2077  return xroad_str("unknown");
2078  }
2079  case xroad_rej_reason_internal_error:
2080  {
2081  return xroad_str("internal_error");
2082  }
2083  case xroad_rej_reason_tran_limit:
2084  {
2085  return xroad_str("tran_limit");
2086  }
2087  case xroad_rej_reason_removed:
2088  {
2089  return xroad_str("removed");
2090  }
2091  case xroad_rej_reason_guard:
2092  {
2093  return xroad_str("guard");
2094  }
2095  case xroad_rej_reason_exchange:
2096  {
2097  return xroad_str("exchange");
2098  }
2099  case xroad_rej_reason_try_again:
2100  {
2101  return xroad_str("try_again");
2102  }
2103  case xroad_rej_reason_timeout:
2104  {
2105  return xroad_str("timeout");
2106  }
2107  case xroad_rej_reason_wrong_order:
2108  {
2109  return xroad_str("wrong_order");
2110  }
2111  case xroad_rej_reason_unknown_order:
2112  {
2113  return xroad_str("unknown_order");
2114  }
2115  case xroad_rej_reason_locked_order:
2116  {
2117  return xroad_str("locked_order");
2118  }
2119  case xroad_rej_reason_cross:
2120  {
2121  return xroad_str("cross");
2122  }
2123  case xroad_rej_reason_cross_book:
2124  {
2125  return xroad_str("cross_book");
2126  }
2127  case xroad_rej_reason_routing:
2128  {
2129  return xroad_str("routing");
2130  }
2131  case xroad_rej_reason_expired:
2132  {
2133  return xroad_str("expired");
2134  }
2135  default:
2136  {
2137  return xroad_str_null;
2138  }
2139  }
2140 }
2141 
2142 //--------------------------------------------------------------------------------------------------------------------//
2143 static inline xroad_rej_reason_t xroad_rej_reason_from_str(xroad_str_t val)
2144 {
2145  if (!xroad_str_cmp(val, xroad_str("other")))
2146  {
2147  return xroad_rej_reason_other;
2148  }
2149  if (!xroad_str_cmp(val, xroad_str("too_late")))
2150  {
2151  return xroad_rej_reason_too_late;
2152  }
2153  if (!xroad_str_cmp(val, xroad_str("unknown_instr")))
2154  {
2155  return xroad_rej_reason_unknown_instr;
2156  }
2157  if (!xroad_str_cmp(val, xroad_str("duplicate")))
2158  {
2159  return xroad_rej_reason_duplicate;
2160  }
2161  if (!xroad_str_cmp(val, xroad_str("exceed_limit")))
2162  {
2163  return xroad_rej_reason_exceed_limit;
2164  }
2165  if (!xroad_str_cmp(val, xroad_str("exch_closed")))
2166  {
2167  return xroad_rej_reason_exch_closed;
2168  }
2169  if (!xroad_str_cmp(val, xroad_str("broker_opt")))
2170  {
2171  return xroad_rej_reason_broker_opt;
2172  }
2173  if (!xroad_str_cmp(val, xroad_str("wrong_account")))
2174  {
2175  return xroad_rej_reason_wrong_account;
2176  }
2177  if (!xroad_str_cmp(val, xroad_str("already_in_pending")))
2178  {
2179  return xroad_rej_reason_already_in_pending;
2180  }
2181  if (!xroad_str_cmp(val, xroad_str("unknown")))
2182  {
2183  return xroad_rej_reason_unknown;
2184  }
2185  if (!xroad_str_cmp(val, xroad_str("internal_error")))
2186  {
2187  return xroad_rej_reason_internal_error;
2188  }
2189  if (!xroad_str_cmp(val, xroad_str("tran_limit")))
2190  {
2191  return xroad_rej_reason_tran_limit;
2192  }
2193  if (!xroad_str_cmp(val, xroad_str("removed")))
2194  {
2195  return xroad_rej_reason_removed;
2196  }
2197  if (!xroad_str_cmp(val, xroad_str("guard")))
2198  {
2199  return xroad_rej_reason_guard;
2200  }
2201  if (!xroad_str_cmp(val, xroad_str("exchange")))
2202  {
2203  return xroad_rej_reason_exchange;
2204  }
2205  if (!xroad_str_cmp(val, xroad_str("try_again")))
2206  {
2207  return xroad_rej_reason_try_again;
2208  }
2209  if (!xroad_str_cmp(val, xroad_str("timeout")))
2210  {
2211  return xroad_rej_reason_timeout;
2212  }
2213  if (!xroad_str_cmp(val, xroad_str("wrong_order")))
2214  {
2215  return xroad_rej_reason_wrong_order;
2216  }
2217  if (!xroad_str_cmp(val, xroad_str("unknown_order")))
2218  {
2219  return xroad_rej_reason_unknown_order;
2220  }
2221  if (!xroad_str_cmp(val, xroad_str("locked_order")))
2222  {
2223  return xroad_rej_reason_locked_order;
2224  }
2225  if (!xroad_str_cmp(val, xroad_str("cross")))
2226  {
2227  return xroad_rej_reason_cross;
2228  }
2229  if (!xroad_str_cmp(val, xroad_str("cross_book")))
2230  {
2231  return xroad_rej_reason_cross_book;
2232  }
2233  if (!xroad_str_cmp(val, xroad_str("routing")))
2234  {
2235  return xroad_rej_reason_routing;
2236  }
2237  if (!xroad_str_cmp(val, xroad_str("expired")))
2238  {
2239  return xroad_rej_reason_expired;
2240  }
2241  return (xroad_rej_reason_t)0;
2242 }
2243 
2244 //--------------------------------------------------------------------------------------------------------------------//
2245 static inline xroad_str_t xroad_rej_reason_get_text(xroad_rej_reason_t val)
2246 {
2247  switch(val)
2248  {
2249  case xroad_rej_reason_other:
2250  {
2251  return xroad_str("other");
2252  }
2253  case xroad_rej_reason_too_late:
2254  {
2255  return xroad_str("too late");
2256  }
2257  case xroad_rej_reason_unknown_instr:
2258  {
2259  return xroad_str("unknown instr");
2260  }
2261  case xroad_rej_reason_duplicate:
2262  {
2263  return xroad_str("duplicate");
2264  }
2265  case xroad_rej_reason_exceed_limit:
2266  {
2267  return xroad_str("exceed limit");
2268  }
2269  case xroad_rej_reason_exch_closed:
2270  {
2271  return xroad_str("exchange closed");
2272  }
2273  case xroad_rej_reason_broker_opt:
2274  {
2275  return xroad_str("broker opt");
2276  }
2277  case xroad_rej_reason_wrong_account:
2278  {
2279  return xroad_str("wrong account");
2280  }
2281  case xroad_rej_reason_already_in_pending:
2282  {
2283  return xroad_str("already in pending");
2284  }
2285  case xroad_rej_reason_unknown:
2286  {
2287  return xroad_str("unknown");
2288  }
2289  case xroad_rej_reason_internal_error:
2290  {
2291  return xroad_str("internal error");
2292  }
2293  case xroad_rej_reason_tran_limit:
2294  {
2295  return xroad_str("tran limit");
2296  }
2297  case xroad_rej_reason_removed:
2298  {
2299  return xroad_str("removed");
2300  }
2301  case xroad_rej_reason_guard:
2302  {
2303  return xroad_str("guard");
2304  }
2305  case xroad_rej_reason_exchange:
2306  {
2307  return xroad_str("exchange");
2308  }
2309  case xroad_rej_reason_try_again:
2310  {
2311  return xroad_str("try again");
2312  }
2313  case xroad_rej_reason_timeout:
2314  {
2315  return xroad_str("timeout");
2316  }
2317  case xroad_rej_reason_wrong_order:
2318  {
2319  return xroad_str("wrong order");
2320  }
2321  case xroad_rej_reason_unknown_order:
2322  {
2323  return xroad_str("unknown order");
2324  }
2325  case xroad_rej_reason_locked_order:
2326  {
2327  return xroad_str("locked order");
2328  }
2329  case xroad_rej_reason_cross:
2330  {
2331  return xroad_str("cross");
2332  }
2333  case xroad_rej_reason_cross_book:
2334  {
2335  return xroad_str("cross_book");
2336  }
2337  case xroad_rej_reason_routing:
2338  {
2339  return xroad_str("routing failed");
2340  }
2341  case xroad_rej_reason_expired:
2342  {
2343  return xroad_str("expired");
2344  }
2345  default:
2346  {
2347  return xroad_str_null;
2348  }
2349  }
2350 }
2351 
2352 //--------------------------------------------------------------------------------------------------------------------//
2353 static inline xroad_str_t xroad_alarm_level_to_str(xroad_alarm_level_t val)
2354 {
2355  switch(val)
2356  {
2357  case xroad_alarm_level_error:
2358  {
2359  return xroad_str("error");
2360  }
2361  case xroad_alarm_level_warning:
2362  {
2363  return xroad_str("warning");
2364  }
2365  case xroad_alarm_level_notice:
2366  {
2367  return xroad_str("notice");
2368  }
2369  default:
2370  {
2371  return xroad_str_null;
2372  }
2373  }
2374 }
2375 
2376 //--------------------------------------------------------------------------------------------------------------------//
2377 static inline xroad_alarm_level_t xroad_alarm_level_from_str(xroad_str_t val)
2378 {
2379  if (!xroad_str_cmp(val, xroad_str("error")))
2380  {
2381  return xroad_alarm_level_error;
2382  }
2383  if (!xroad_str_cmp(val, xroad_str("warning")))
2384  {
2385  return xroad_alarm_level_warning;
2386  }
2387  if (!xroad_str_cmp(val, xroad_str("notice")))
2388  {
2389  return xroad_alarm_level_notice;
2390  }
2391  return (xroad_alarm_level_t)0;
2392 }
2393 
2394 //--------------------------------------------------------------------------------------------------------------------//
2395 static inline xroad_str_t xroad_alarm_level_get_text(xroad_alarm_level_t val)
2396 {
2397  switch(val)
2398  {
2399  case xroad_alarm_level_error:
2400  {
2401  return xroad_str("error");
2402  }
2403  case xroad_alarm_level_warning:
2404  {
2405  return xroad_str("warning");
2406  }
2407  case xroad_alarm_level_notice:
2408  {
2409  return xroad_str("notice");
2410  }
2411  default:
2412  {
2413  return xroad_str_null;
2414  }
2415  }
2416 }
2417 
2418 //--------------------------------------------------------------------------------------------------------------------//
2419 static inline xroad_str_t xroad_order_fix_status_to_str(xroad_order_fix_status_t val)
2420 {
2421  switch(val)
2422  {
2423  case xroad_order_fix_status_new:
2424  {
2425  return xroad_str("new");
2426  }
2427  case xroad_order_fix_status_partially_filled:
2428  {
2429  return xroad_str("partially_filled");
2430  }
2431  case xroad_order_fix_status_filled:
2432  {
2433  return xroad_str("filled");
2434  }
2435  case xroad_order_fix_status_canceled:
2436  {
2437  return xroad_str("canceled");
2438  }
2439  case xroad_order_fix_status_pending_cancel:
2440  {
2441  return xroad_str("pending_cancel");
2442  }
2443  case xroad_order_fix_status_rejected:
2444  {
2445  return xroad_str("rejected");
2446  }
2447  case xroad_order_fix_status_pending_new:
2448  {
2449  return xroad_str("pending_new");
2450  }
2451  case xroad_order_fix_status_expired:
2452  {
2453  return xroad_str("expired");
2454  }
2455  case xroad_order_fix_status_pending_replace:
2456  {
2457  return xroad_str("pending_replace");
2458  }
2459  default:
2460  {
2461  return xroad_str_null;
2462  }
2463  }
2464 }
2465 
2466 //--------------------------------------------------------------------------------------------------------------------//
2467 static inline xroad_order_fix_status_t xroad_order_fix_status_from_str(xroad_str_t val)
2468 {
2469  if (!xroad_str_cmp(val, xroad_str("new")))
2470  {
2471  return xroad_order_fix_status_new;
2472  }
2473  if (!xroad_str_cmp(val, xroad_str("partially_filled")))
2474  {
2475  return xroad_order_fix_status_partially_filled;
2476  }
2477  if (!xroad_str_cmp(val, xroad_str("filled")))
2478  {
2479  return xroad_order_fix_status_filled;
2480  }
2481  if (!xroad_str_cmp(val, xroad_str("canceled")))
2482  {
2483  return xroad_order_fix_status_canceled;
2484  }
2485  if (!xroad_str_cmp(val, xroad_str("pending_cancel")))
2486  {
2487  return xroad_order_fix_status_pending_cancel;
2488  }
2489  if (!xroad_str_cmp(val, xroad_str("rejected")))
2490  {
2491  return xroad_order_fix_status_rejected;
2492  }
2493  if (!xroad_str_cmp(val, xroad_str("pending_new")))
2494  {
2495  return xroad_order_fix_status_pending_new;
2496  }
2497  if (!xroad_str_cmp(val, xroad_str("expired")))
2498  {
2499  return xroad_order_fix_status_expired;
2500  }
2501  if (!xroad_str_cmp(val, xroad_str("pending_replace")))
2502  {
2503  return xroad_order_fix_status_pending_replace;
2504  }
2505  return (xroad_order_fix_status_t)0;
2506 }
2507 
2508 //--------------------------------------------------------------------------------------------------------------------//
2509 static inline xroad_str_t xroad_order_fix_status_get_text(xroad_order_fix_status_t val)
2510 {
2511  switch(val)
2512  {
2513  case xroad_order_fix_status_new:
2514  {
2515  return xroad_str("new");
2516  }
2517  case xroad_order_fix_status_partially_filled:
2518  {
2519  return xroad_str("partially filled");
2520  }
2521  case xroad_order_fix_status_filled:
2522  {
2523  return xroad_str("filled");
2524  }
2525  case xroad_order_fix_status_canceled:
2526  {
2527  return xroad_str("canceled");
2528  }
2529  case xroad_order_fix_status_pending_cancel:
2530  {
2531  return xroad_str("pending cancel");
2532  }
2533  case xroad_order_fix_status_rejected:
2534  {
2535  return xroad_str("rejected");
2536  }
2537  case xroad_order_fix_status_pending_new:
2538  {
2539  return xroad_str("pending new");
2540  }
2541  case xroad_order_fix_status_expired:
2542  {
2543  return xroad_str("expired");
2544  }
2545  case xroad_order_fix_status_pending_replace:
2546  {
2547  return xroad_str("pending replace");
2548  }
2549  default:
2550  {
2551  return xroad_str_null;
2552  }
2553  }
2554 }
2555 
2556 //--------------------------------------------------------------------------------------------------------------------//
2557 static inline xroad_str_t xroad_order_status_to_str(xroad_order_status_t val)
2558 {
2559  switch(val)
2560  {
2561  case xroad_order_status_initial:
2562  {
2563  return xroad_str("initial");
2564  }
2565  case xroad_order_status_active:
2566  {
2567  return xroad_str("active");
2568  }
2569  case xroad_order_status_filled:
2570  {
2571  return xroad_str("filled");
2572  }
2573  case xroad_order_status_canceled:
2574  {
2575  return xroad_str("canceled");
2576  }
2577  case xroad_order_status_rejected:
2578  {
2579  return xroad_str("rejected");
2580  }
2581  case xroad_order_status_expired:
2582  {
2583  return xroad_str("expired");
2584  }
2585  case xroad_order_status_removed:
2586  {
2587  return xroad_str("removed");
2588  }
2589  case xroad_order_status_awaiting_active:
2590  {
2591  return xroad_str("awaiting_active");
2592  }
2593  case xroad_order_status_awaiting_cancel:
2594  {
2595  return xroad_str("awaiting_cancel");
2596  }
2597  case xroad_order_status_awaiting_replace:
2598  {
2599  return xroad_str("awaiting_replace");
2600  }
2601  default:
2602  {
2603  return xroad_str_null;
2604  }
2605  }
2606 }
2607 
2608 //--------------------------------------------------------------------------------------------------------------------//
2609 static inline xroad_order_status_t xroad_order_status_from_str(xroad_str_t val)
2610 {
2611  if (!xroad_str_cmp(val, xroad_str("initial")))
2612  {
2613  return xroad_order_status_initial;
2614  }
2615  if (!xroad_str_cmp(val, xroad_str("active")))
2616  {
2617  return xroad_order_status_active;
2618  }
2619  if (!xroad_str_cmp(val, xroad_str("filled")))
2620  {
2621  return xroad_order_status_filled;
2622  }
2623  if (!xroad_str_cmp(val, xroad_str("canceled")))
2624  {
2625  return xroad_order_status_canceled;
2626  }
2627  if (!xroad_str_cmp(val, xroad_str("rejected")))
2628  {
2629  return xroad_order_status_rejected;
2630  }
2631  if (!xroad_str_cmp(val, xroad_str("expired")))
2632  {
2633  return xroad_order_status_expired;
2634  }
2635  if (!xroad_str_cmp(val, xroad_str("removed")))
2636  {
2637  return xroad_order_status_removed;
2638  }
2639  if (!xroad_str_cmp(val, xroad_str("awaiting_active")))
2640  {
2641  return xroad_order_status_awaiting_active;
2642  }
2643  if (!xroad_str_cmp(val, xroad_str("awaiting_cancel")))
2644  {
2645  return xroad_order_status_awaiting_cancel;
2646  }
2647  if (!xroad_str_cmp(val, xroad_str("awaiting_replace")))
2648  {
2649  return xroad_order_status_awaiting_replace;
2650  }
2651  return (xroad_order_status_t)0;
2652 }
2653 
2654 //--------------------------------------------------------------------------------------------------------------------//
2655 static inline xroad_str_t xroad_order_status_get_text(xroad_order_status_t val)
2656 {
2657  switch(val)
2658  {
2659  case xroad_order_status_initial:
2660  {
2661  return xroad_str("initial");
2662  }
2663  case xroad_order_status_active:
2664  {
2665  return xroad_str("active");
2666  }
2667  case xroad_order_status_filled:
2668  {
2669  return xroad_str("filled");
2670  }
2671  case xroad_order_status_canceled:
2672  {
2673  return xroad_str("canceled");
2674  }
2675  case xroad_order_status_rejected:
2676  {
2677  return xroad_str("rejected");
2678  }
2679  case xroad_order_status_expired:
2680  {
2681  return xroad_str("expired");
2682  }
2683  case xroad_order_status_removed:
2684  {
2685  return xroad_str("removed");
2686  }
2687  case xroad_order_status_awaiting_active:
2688  {
2689  return xroad_str("awaiting active");
2690  }
2691  case xroad_order_status_awaiting_cancel:
2692  {
2693  return xroad_str("awaiting cancel");
2694  }
2695  case xroad_order_status_awaiting_replace:
2696  {
2697  return xroad_str("awaiting replace");
2698  }
2699  default:
2700  {
2701  return xroad_str_null;
2702  }
2703  }
2704 }
2705 
2706 //--------------------------------------------------------------------------------------------------------------------//
2707 static inline xroad_str_t xroad_exec_type_to_str(xroad_exec_type_t val)
2708 {
2709  switch(val)
2710  {
2711  case xroad_exec_type_new:
2712  {
2713  return xroad_str("new");
2714  }
2715  case xroad_exec_type_canceled:
2716  {
2717  return xroad_str("canceled");
2718  }
2719  case xroad_exec_type_replace:
2720  {
2721  return xroad_str("replace");
2722  }
2723  case xroad_exec_type_pending_cancel:
2724  {
2725  return xroad_str("pending_cancel");
2726  }
2727  case xroad_exec_type_rejected:
2728  {
2729  return xroad_str("rejected");
2730  }
2731  case xroad_exec_type_expired:
2732  {
2733  return xroad_str("expired");
2734  }
2735  case xroad_exec_type_pending_replace:
2736  {
2737  return xroad_str("pending_replace");
2738  }
2739  case xroad_exec_type_trade:
2740  {
2741  return xroad_str("trade");
2742  }
2743  default:
2744  {
2745  return xroad_str_null;
2746  }
2747  }
2748 }
2749 
2750 //--------------------------------------------------------------------------------------------------------------------//
2751 static inline xroad_exec_type_t xroad_exec_type_from_str(xroad_str_t val)
2752 {
2753  if (!xroad_str_cmp(val, xroad_str("new")))
2754  {
2755  return xroad_exec_type_new;
2756  }
2757  if (!xroad_str_cmp(val, xroad_str("canceled")))
2758  {
2759  return xroad_exec_type_canceled;
2760  }
2761  if (!xroad_str_cmp(val, xroad_str("replace")))
2762  {
2763  return xroad_exec_type_replace;
2764  }
2765  if (!xroad_str_cmp(val, xroad_str("pending_cancel")))
2766  {
2767  return xroad_exec_type_pending_cancel;
2768  }
2769  if (!xroad_str_cmp(val, xroad_str("rejected")))
2770  {
2771  return xroad_exec_type_rejected;
2772  }
2773  if (!xroad_str_cmp(val, xroad_str("expired")))
2774  {
2775  return xroad_exec_type_expired;
2776  }
2777  if (!xroad_str_cmp(val, xroad_str("pending_replace")))
2778  {
2779  return xroad_exec_type_pending_replace;
2780  }
2781  if (!xroad_str_cmp(val, xroad_str("trade")))
2782  {
2783  return xroad_exec_type_trade;
2784  }
2785  return (xroad_exec_type_t)0;
2786 }
2787 
2788 //--------------------------------------------------------------------------------------------------------------------//
2789 static inline xroad_str_t xroad_exec_type_get_text(xroad_exec_type_t val)
2790 {
2791  switch(val)
2792  {
2793  case xroad_exec_type_new:
2794  {
2795  return xroad_str("new");
2796  }
2797  case xroad_exec_type_canceled:
2798  {
2799  return xroad_str("canceled");
2800  }
2801  case xroad_exec_type_replace:
2802  {
2803  return xroad_str("replace");
2804  }
2805  case xroad_exec_type_pending_cancel:
2806  {
2807  return xroad_str("pending cancel");
2808  }
2809  case xroad_exec_type_rejected:
2810  {
2811  return xroad_str("rejected");
2812  }
2813  case xroad_exec_type_expired:
2814  {
2815  return xroad_str("expired");
2816  }
2817  case xroad_exec_type_pending_replace:
2818  {
2819  return xroad_str("pending replace");
2820  }
2821  case xroad_exec_type_trade:
2822  {
2823  return xroad_str("trade");
2824  }
2825  default:
2826  {
2827  return xroad_str_null;
2828  }
2829  }
2830 }
2831 
2832 //--------------------------------------------------------------------------------------------------------------------//
2833 static inline xroad_str_t xroad_session_state_to_str(xroad_session_state_t val)
2834 {
2835  switch(val)
2836  {
2837  case xroad_session_state_disconnected:
2838  {
2839  return xroad_str("disconnected");
2840  }
2841  case xroad_session_state_connected:
2842  {
2843  return xroad_str("connected");
2844  }
2845  case xroad_session_state_awaiting_logon:
2846  {
2847  return xroad_str("awaiting_logon");
2848  }
2849  case xroad_session_state_awaiting_logon_ack:
2850  {
2851  return xroad_str("awaiting_logon_ack");
2852  }
2853  case xroad_session_state_awaiting_test_ack:
2854  {
2855  return xroad_str("awaiting_test_ack");
2856  }
2857  case xroad_session_state_awaiting_disconnect:
2858  {
2859  return xroad_str("awaiting_disconnect");
2860  }
2861  case xroad_session_state_awaiting_connect:
2862  {
2863  return xroad_str("awaiting_connect");
2864  }
2865  default:
2866  {
2867  return xroad_str_null;
2868  }
2869  }
2870 }
2871 
2872 //--------------------------------------------------------------------------------------------------------------------//
2873 static inline xroad_session_state_t xroad_session_state_from_str(xroad_str_t val)
2874 {
2875  if (!xroad_str_cmp(val, xroad_str("disconnected")))
2876  {
2877  return xroad_session_state_disconnected;
2878  }
2879  if (!xroad_str_cmp(val, xroad_str("connected")))
2880  {
2881  return xroad_session_state_connected;
2882  }
2883  if (!xroad_str_cmp(val, xroad_str("awaiting_logon")))
2884  {
2885  return xroad_session_state_awaiting_logon;
2886  }
2887  if (!xroad_str_cmp(val, xroad_str("awaiting_logon_ack")))
2888  {
2889  return xroad_session_state_awaiting_logon_ack;
2890  }
2891  if (!xroad_str_cmp(val, xroad_str("awaiting_test_ack")))
2892  {
2893  return xroad_session_state_awaiting_test_ack;
2894  }
2895  if (!xroad_str_cmp(val, xroad_str("awaiting_disconnect")))
2896  {
2897  return xroad_session_state_awaiting_disconnect;
2898  }
2899  if (!xroad_str_cmp(val, xroad_str("awaiting_connect")))
2900  {
2901  return xroad_session_state_awaiting_connect;
2902  }
2903  return (xroad_session_state_t)0;
2904 }
2905 
2906 //--------------------------------------------------------------------------------------------------------------------//
2907 static inline xroad_str_t xroad_session_state_get_text(xroad_session_state_t val)
2908 {
2909  switch(val)
2910  {
2911  case xroad_session_state_disconnected:
2912  {
2913  return xroad_str("disconnected");
2914  }
2915  case xroad_session_state_connected:
2916  {
2917  return xroad_str("connected");
2918  }
2919  case xroad_session_state_awaiting_logon:
2920  {
2921  return xroad_str("awaiting logon");
2922  }
2923  case xroad_session_state_awaiting_logon_ack:
2924  {
2925  return xroad_str("awaiting logon ack");
2926  }
2927  case xroad_session_state_awaiting_test_ack:
2928  {
2929  return xroad_str("awaiting test ack");
2930  }
2931  case xroad_session_state_awaiting_disconnect:
2932  {
2933  return xroad_str("awaiting disconnect");
2934  }
2935  case xroad_session_state_awaiting_connect:
2936  {
2937  return xroad_str("awaiting connect");
2938  }
2939  default:
2940  {
2941  return xroad_str_null;
2942  }
2943  }
2944 }
2945 
2946 //--------------------------------------------------------------------------------------------------------------------//
2947 static inline xroad_str_t xroad_fix_session_status_to_str(xroad_fix_session_status_t val)
2948 {
2949  switch(val)
2950  {
2951  case xroad_fix_session_status_started:
2952  {
2953  return xroad_str("started");
2954  }
2955  case xroad_fix_session_status_finished:
2956  {
2957  return xroad_str("finished");
2958  }
2959  default:
2960  {
2961  return xroad_str_null;
2962  }
2963  }
2964 }
2965 
2966 //--------------------------------------------------------------------------------------------------------------------//
2967 static inline xroad_fix_session_status_t xroad_fix_session_status_from_str(xroad_str_t val)
2968 {
2969  if (!xroad_str_cmp(val, xroad_str("started")))
2970  {
2971  return xroad_fix_session_status_started;
2972  }
2973  if (!xroad_str_cmp(val, xroad_str("finished")))
2974  {
2975  return xroad_fix_session_status_finished;
2976  }
2977  return (xroad_fix_session_status_t)0;
2978 }
2979 
2980 //--------------------------------------------------------------------------------------------------------------------//
2981 static inline xroad_str_t xroad_fix_session_status_get_text(xroad_fix_session_status_t val)
2982 {
2983  switch(val)
2984  {
2985  case xroad_fix_session_status_started:
2986  {
2987  return xroad_str("started");
2988  }
2989  case xroad_fix_session_status_finished:
2990  {
2991  return xroad_str("finished");
2992  }
2993  default:
2994  {
2995  return xroad_str_null;
2996  }
2997  }
2998 }
2999 
3000 //--------------------------------------------------------------------------------------------------------------------//
3001 static inline xroad_str_t xroad_rej_response_to_to_str(xroad_rej_response_to_t val)
3002 {
3003  switch(val)
3004  {
3005  case xroad_rej_response_to_cancel:
3006  {
3007  return xroad_str("cancel");
3008  }
3009  case xroad_rej_response_to_replace:
3010  {
3011  return xroad_str("replace");
3012  }
3013  default:
3014  {
3015  return xroad_str_null;
3016  }
3017  }
3018 }
3019 
3020 //--------------------------------------------------------------------------------------------------------------------//
3021 static inline xroad_rej_response_to_t xroad_rej_response_to_from_str(xroad_str_t val)
3022 {
3023  if (!xroad_str_cmp(val, xroad_str("cancel")))
3024  {
3025  return xroad_rej_response_to_cancel;
3026  }
3027  if (!xroad_str_cmp(val, xroad_str("replace")))
3028  {
3029  return xroad_rej_response_to_replace;
3030  }
3031  return (xroad_rej_response_to_t)0;
3032 }
3033 
3034 //--------------------------------------------------------------------------------------------------------------------//
3035 static inline xroad_str_t xroad_rej_response_to_get_text(xroad_rej_response_to_t val)
3036 {
3037  switch(val)
3038  {
3039  case xroad_rej_response_to_cancel:
3040  {
3041  return xroad_str("response_to_cancel");
3042  }
3043  case xroad_rej_response_to_replace:
3044  {
3045  return xroad_str("response_to_replace");
3046  }
3047  default:
3048  {
3049  return xroad_str_null;
3050  }
3051  }
3052 }
3053 
3054 //--------------------------------------------------------------------------------------------------------------------//
3055 static inline xroad_str_t xroad_field_type_to_str(xroad_field_type_t val)
3056 {
3057  switch(val)
3058  {
3059  case xroad_field_type_string:
3060  {
3061  return xroad_str("string");
3062  }
3063  case xroad_field_type_integer:
3064  {
3065  return xroad_str("integer");
3066  }
3067  case xroad_field_type_double:
3068  {
3069  return xroad_str("double");
3070  }
3071  case xroad_field_type_time:
3072  {
3073  return xroad_str("time");
3074  }
3075  default:
3076  {
3077  return xroad_str_null;
3078  }
3079  }
3080 }
3081 
3082 //--------------------------------------------------------------------------------------------------------------------//
3083 static inline xroad_field_type_t xroad_field_type_from_str(xroad_str_t val)
3084 {
3085  if (!xroad_str_cmp(val, xroad_str("string")))
3086  {
3087  return xroad_field_type_string;
3088  }
3089  if (!xroad_str_cmp(val, xroad_str("integer")))
3090  {
3091  return xroad_field_type_integer;
3092  }
3093  if (!xroad_str_cmp(val, xroad_str("double")))
3094  {
3095  return xroad_field_type_double;
3096  }
3097  if (!xroad_str_cmp(val, xroad_str("time")))
3098  {
3099  return xroad_field_type_time;
3100  }
3101  return (xroad_field_type_t)0;
3102 }
3103 
3104 //--------------------------------------------------------------------------------------------------------------------//
3105 static inline xroad_str_t xroad_field_type_get_text(xroad_field_type_t val)
3106 {
3107  switch(val)
3108  {
3109  case xroad_field_type_string:
3110  {
3111  return xroad_str("string");
3112  }
3113  case xroad_field_type_integer:
3114  {
3115  return xroad_str("integer");
3116  }
3117  case xroad_field_type_double:
3118  {
3119  return xroad_str("double");
3120  }
3121  case xroad_field_type_time:
3122  {
3123  return xroad_str("time");
3124  }
3125  default:
3126  {
3127  return xroad_str_null;
3128  }
3129  }
3130 }
3131 
3132 //--------------------------------------------------------------------------------------------------------------------//
3133 static inline xroad_str_t xroad_prop_type_to_str(xroad_prop_type_t val)
3134 {
3135  switch(val)
3136  {
3137  case xroad_prop_type_string:
3138  {
3139  return xroad_str("string");
3140  }
3141  case xroad_prop_type_boolean:
3142  {
3143  return xroad_str("boolean");
3144  }
3145  case xroad_prop_type_integer:
3146  {
3147  return xroad_str("integer");
3148  }
3149  case xroad_prop_type_double:
3150  {
3151  return xroad_str("double");
3152  }
3153  case xroad_prop_type_time:
3154  {
3155  return xroad_str("time");
3156  }
3157  case xroad_prop_type_table:
3158  {
3159  return xroad_str("table");
3160  }
3161  default:
3162  {
3163  return xroad_str_null;
3164  }
3165  }
3166 }
3167 
3168 //--------------------------------------------------------------------------------------------------------------------//
3169 static inline xroad_prop_type_t xroad_prop_type_from_str(xroad_str_t val)
3170 {
3171  if (!xroad_str_cmp(val, xroad_str("string")))
3172  {
3173  return xroad_prop_type_string;
3174  }
3175  if (!xroad_str_cmp(val, xroad_str("boolean")))
3176  {
3177  return xroad_prop_type_boolean;
3178  }
3179  if (!xroad_str_cmp(val, xroad_str("integer")))
3180  {
3181  return xroad_prop_type_integer;
3182  }
3183  if (!xroad_str_cmp(val, xroad_str("double")))
3184  {
3185  return xroad_prop_type_double;
3186  }
3187  if (!xroad_str_cmp(val, xroad_str("time")))
3188  {
3189  return xroad_prop_type_time;
3190  }
3191  if (!xroad_str_cmp(val, xroad_str("table")))
3192  {
3193  return xroad_prop_type_table;
3194  }
3195  return (xroad_prop_type_t)0;
3196 }
3197 
3198 //--------------------------------------------------------------------------------------------------------------------//
3199 static inline xroad_str_t xroad_prop_type_get_text(xroad_prop_type_t val)
3200 {
3201  switch(val)
3202  {
3203  case xroad_prop_type_string:
3204  {
3205  return xroad_str("string");
3206  }
3207  case xroad_prop_type_boolean:
3208  {
3209  return xroad_str("boolean");
3210  }
3211  case xroad_prop_type_integer:
3212  {
3213  return xroad_str("integer");
3214  }
3215  case xroad_prop_type_double:
3216  {
3217  return xroad_str("double");
3218  }
3219  case xroad_prop_type_time:
3220  {
3221  return xroad_str("time");
3222  }
3223  case xroad_prop_type_table:
3224  {
3225  return xroad_str("table");
3226  }
3227  default:
3228  {
3229  return xroad_str_null;
3230  }
3231  }
3232 }
3233 
3234 //--------------------------------------------------------------------------------------------------------------------//
3235 static inline xroad_str_t xroad_opt_mm_state_to_str(xroad_opt_mm_state_t val)
3236 {
3237  switch(val)
3238  {
3239  case xroad_opt_mm_state_disabled:
3240  {
3241  return xroad_str("disabled");
3242  }
3243  case xroad_opt_mm_state_pending:
3244  {
3245  return xroad_str("pending");
3246  }
3247  case xroad_opt_mm_state_active:
3248  {
3249  return xroad_str("active");
3250  }
3251  case xroad_opt_mm_state_error:
3252  {
3253  return xroad_str("error");
3254  }
3255  case xroad_opt_mm_state_filled:
3256  {
3257  return xroad_str("filled");
3258  }
3259  default:
3260  {
3261  return xroad_str_null;
3262  }
3263  }
3264 }
3265 
3266 //--------------------------------------------------------------------------------------------------------------------//
3267 static inline xroad_opt_mm_state_t xroad_opt_mm_state_from_str(xroad_str_t val)
3268 {
3269  if (!xroad_str_cmp(val, xroad_str("disabled")))
3270  {
3271  return xroad_opt_mm_state_disabled;
3272  }
3273  if (!xroad_str_cmp(val, xroad_str("pending")))
3274  {
3275  return xroad_opt_mm_state_pending;
3276  }
3277  if (!xroad_str_cmp(val, xroad_str("active")))
3278  {
3279  return xroad_opt_mm_state_active;
3280  }
3281  if (!xroad_str_cmp(val, xroad_str("error")))
3282  {
3283  return xroad_opt_mm_state_error;
3284  }
3285  if (!xroad_str_cmp(val, xroad_str("filled")))
3286  {
3287  return xroad_opt_mm_state_filled;
3288  }
3289  return (xroad_opt_mm_state_t)0;
3290 }
3291 
3292 //--------------------------------------------------------------------------------------------------------------------//
3293 static inline xroad_str_t xroad_opt_mm_state_get_text(xroad_opt_mm_state_t val)
3294 {
3295  switch(val)
3296  {
3297  case xroad_opt_mm_state_disabled:
3298  {
3299  return xroad_str("disabled");
3300  }
3301  case xroad_opt_mm_state_pending:
3302  {
3303  return xroad_str("pending");
3304  }
3305  case xroad_opt_mm_state_active:
3306  {
3307  return xroad_str("active");
3308  }
3309  case xroad_opt_mm_state_error:
3310  {
3311  return xroad_str("error");
3312  }
3313  case xroad_opt_mm_state_filled:
3314  {
3315  return xroad_str("filled");
3316  }
3317  default:
3318  {
3319  return xroad_str_null;
3320  }
3321  }
3322 }
3323 
3324 //--------------------------------------------------------------------------------------------------------------------//
3325 static inline xroad_str_t xroad_reset_hint_to_str(xroad_reset_hint_t val)
3326 {
3327  switch(val)
3328  {
3329  case xroad_reset_hint_statistic:
3330  {
3331  return xroad_str("statistic");
3332  }
3333  case xroad_reset_hint_fix_session:
3334  {
3335  return xroad_str("fix_session");
3336  }
3337  case xroad_reset_hint_state:
3338  {
3339  return xroad_str("state");
3340  }
3341  default:
3342  {
3343  return xroad_str_null;
3344  }
3345  }
3346 }
3347 
3348 //--------------------------------------------------------------------------------------------------------------------//
3349 static inline xroad_reset_hint_t xroad_reset_hint_from_str(xroad_str_t val)
3350 {
3351  if (!xroad_str_cmp(val, xroad_str("statistic")))
3352  {
3353  return xroad_reset_hint_statistic;
3354  }
3355  if (!xroad_str_cmp(val, xroad_str("fix_session")))
3356  {
3357  return xroad_reset_hint_fix_session;
3358  }
3359  if (!xroad_str_cmp(val, xroad_str("state")))
3360  {
3361  return xroad_reset_hint_state;
3362  }
3363  return (xroad_reset_hint_t)0;
3364 }
3365 
3366 //--------------------------------------------------------------------------------------------------------------------//
3367 static inline xroad_str_t xroad_reset_hint_get_text(xroad_reset_hint_t val)
3368 {
3369  switch(val)
3370  {
3371  case xroad_reset_hint_statistic:
3372  {
3373  return xroad_str("statistic");
3374  }
3375  case xroad_reset_hint_fix_session:
3376  {
3377  return xroad_str("fix_session");
3378  }
3379  case xroad_reset_hint_state:
3380  {
3381  return xroad_str("state");
3382  }
3383  default:
3384  {
3385  return xroad_str_null;
3386  }
3387  }
3388 }
3389 
3390 //--------------------------------------------------------------------------------------------------------------------//
3391 static inline xroad_str_t xroad_callput_to_str(xroad_callput_t val)
3392 {
3393  switch(val)
3394  {
3395  case xroad_callput_call:
3396  {
3397  return xroad_str("call");
3398  }
3399  case xroad_callput_put:
3400  {
3401  return xroad_str("put");
3402  }
3403  default:
3404  {
3405  return xroad_str_null;
3406  }
3407  }
3408 }
3409 
3410 //--------------------------------------------------------------------------------------------------------------------//
3411 static inline xroad_callput_t xroad_callput_from_str(xroad_str_t val)
3412 {
3413  if (!xroad_str_cmp(val, xroad_str("call")))
3414  {
3415  return xroad_callput_call;
3416  }
3417  if (!xroad_str_cmp(val, xroad_str("put")))
3418  {
3419  return xroad_callput_put;
3420  }
3421  return (xroad_callput_t)0;
3422 }
3423 
3424 //--------------------------------------------------------------------------------------------------------------------//
3425 static inline xroad_str_t xroad_callput_get_text(xroad_callput_t val)
3426 {
3427  switch(val)
3428  {
3429  case xroad_callput_call:
3430  {
3431  return xroad_str("call");
3432  }
3433  case xroad_callput_put:
3434  {
3435  return xroad_str("put");
3436  }
3437  default:
3438  {
3439  return xroad_str_null;
3440  }
3441  }
3442 }
3443 
3444 //--------------------------------------------------------------------------------------------------------------------//
3445 static inline xroad_str_t xroad_calc_mid_to_str(xroad_calc_mid_t val)
3446 {
3447  switch(val)
3448  {
3449  case xroad_calc_mid_by_shift:
3450  {
3451  return xroad_str("by_shift");
3452  }
3453  case xroad_calc_mid_by_shift_vol:
3454  {
3455  return xroad_str("by_shift_vol");
3456  }
3457  default:
3458  {
3459  return xroad_str_null;
3460  }
3461  }
3462 }
3463 
3464 //--------------------------------------------------------------------------------------------------------------------//
3465 static inline xroad_calc_mid_t xroad_calc_mid_from_str(xroad_str_t val)
3466 {
3467  if (!xroad_str_cmp(val, xroad_str("by_shift")))
3468  {
3469  return xroad_calc_mid_by_shift;
3470  }
3471  if (!xroad_str_cmp(val, xroad_str("by_shift_vol")))
3472  {
3473  return xroad_calc_mid_by_shift_vol;
3474  }
3475  return (xroad_calc_mid_t)0;
3476 }
3477 
3478 //--------------------------------------------------------------------------------------------------------------------//
3479 static inline xroad_str_t xroad_calc_mid_get_text(xroad_calc_mid_t val)
3480 {
3481  switch(val)
3482  {
3483  case xroad_calc_mid_by_shift:
3484  {
3485  return xroad_str("by_shift");
3486  }
3487  case xroad_calc_mid_by_shift_vol:
3488  {
3489  return xroad_str("by_shift_vol");
3490  }
3491  default:
3492  {
3493  return xroad_str_null;
3494  }
3495  }
3496 }
3497 
3498 //--------------------------------------------------------------------------------------------------------------------//
3499 static inline xroad_str_t xroad_mleg_report_type_to_str(xroad_mleg_report_type_t val)
3500 {
3501  switch(val)
3502  {
3503  case xroad_mleg_report_type_single:
3504  {
3505  return xroad_str("single");
3506  }
3507  case xroad_mleg_report_type_leg:
3508  {
3509  return xroad_str("leg");
3510  }
3511  case xroad_mleg_report_type_mleg_sec:
3512  {
3513  return xroad_str("mleg_sec");
3514  }
3515  default:
3516  {
3517  return xroad_str_null;
3518  }
3519  }
3520 }
3521 
3522 //--------------------------------------------------------------------------------------------------------------------//
3523 static inline xroad_mleg_report_type_t xroad_mleg_report_type_from_str(xroad_str_t val)
3524 {
3525  if (!xroad_str_cmp(val, xroad_str("single")))
3526  {
3527  return xroad_mleg_report_type_single;
3528  }
3529  if (!xroad_str_cmp(val, xroad_str("leg")))
3530  {
3531  return xroad_mleg_report_type_leg;
3532  }
3533  if (!xroad_str_cmp(val, xroad_str("mleg_sec")))
3534  {
3535  return xroad_mleg_report_type_mleg_sec;
3536  }
3537  return (xroad_mleg_report_type_t)0;
3538 }
3539 
3540 //--------------------------------------------------------------------------------------------------------------------//
3541 static inline xroad_str_t xroad_mleg_report_type_get_text(xroad_mleg_report_type_t val)
3542 {
3543  switch(val)
3544  {
3545  case xroad_mleg_report_type_single:
3546  {
3547  return xroad_str("single");
3548  }
3549  case xroad_mleg_report_type_leg:
3550  {
3551  return xroad_str("leg");
3552  }
3553  case xroad_mleg_report_type_mleg_sec:
3554  {
3555  return xroad_str("mleg_sec");
3556  }
3557  default:
3558  {
3559  return xroad_str_null;
3560  }
3561  }
3562 }
3563 
3564 //--------------------------------------------------------------------------------------------------------------------//
3565 static inline xroad_str_t xroad_subs_result_to_str(xroad_subs_result_t val)
3566 {
3567  switch(val)
3568  {
3569  case xroad_subs_result_subscribed:
3570  {
3571  return xroad_str("subscribed");
3572  }
3573  case xroad_subs_result_unsubscribed:
3574  {
3575  return xroad_str("unsubscribed");
3576  }
3577  case xroad_subs_result_already_subscribed:
3578  {
3579  return xroad_str("already_subscribed");
3580  }
3581  case xroad_subs_result_instr_not_found:
3582  {
3583  return xroad_str("instr_not_found");
3584  }
3585  case xroad_subs_result_too_many_subscriptions:
3586  {
3587  return xroad_str("too_many_subscriptions");
3588  }
3589  case xroad_subs_result_internal_error:
3590  {
3591  return xroad_str("internal_error");
3592  }
3593  case xroad_subs_result_external_error:
3594  {
3595  return xroad_str("external_error");
3596  }
3597  default:
3598  {
3599  return xroad_str_null;
3600  }
3601  }
3602 }
3603 
3604 //--------------------------------------------------------------------------------------------------------------------//
3605 static inline xroad_subs_result_t xroad_subs_result_from_str(xroad_str_t val)
3606 {
3607  if (!xroad_str_cmp(val, xroad_str("subscribed")))
3608  {
3609  return xroad_subs_result_subscribed;
3610  }
3611  if (!xroad_str_cmp(val, xroad_str("unsubscribed")))
3612  {
3613  return xroad_subs_result_unsubscribed;
3614  }
3615  if (!xroad_str_cmp(val, xroad_str("already_subscribed")))
3616  {
3617  return xroad_subs_result_already_subscribed;
3618  }
3619  if (!xroad_str_cmp(val, xroad_str("instr_not_found")))
3620  {
3621  return xroad_subs_result_instr_not_found;
3622  }
3623  if (!xroad_str_cmp(val, xroad_str("too_many_subscriptions")))
3624  {
3625  return xroad_subs_result_too_many_subscriptions;
3626  }
3627  if (!xroad_str_cmp(val, xroad_str("internal_error")))
3628  {
3629  return xroad_subs_result_internal_error;
3630  }
3631  if (!xroad_str_cmp(val, xroad_str("external_error")))
3632  {
3633  return xroad_subs_result_external_error;
3634  }
3635  return (xroad_subs_result_t)0;
3636 }
3637 
3638 //--------------------------------------------------------------------------------------------------------------------//
3639 static inline xroad_str_t xroad_subs_result_get_text(xroad_subs_result_t val)
3640 {
3641  switch(val)
3642  {
3643  case xroad_subs_result_subscribed:
3644  {
3645  return xroad_str("subscribed");
3646  }
3647  case xroad_subs_result_unsubscribed:
3648  {
3649  return xroad_str("unsubscribed");
3650  }
3651  case xroad_subs_result_already_subscribed:
3652  {
3653  return xroad_str("already subscribed");
3654  }
3655  case xroad_subs_result_instr_not_found:
3656  {
3657  return xroad_str("instr not found");
3658  }
3659  case xroad_subs_result_too_many_subscriptions:
3660  {
3661  return xroad_str("too many subscriptions");
3662  }
3663  case xroad_subs_result_internal_error:
3664  {
3665  return xroad_str("internal error");
3666  }
3667  case xroad_subs_result_external_error:
3668  {
3669  return xroad_str("external error");
3670  }
3671  default:
3672  {
3673  return xroad_str_null;
3674  }
3675  }
3676 }
3677 
3678 //--------------------------------------------------------------------------------------------------------------------//
3679 static inline xroad_str_t xroad_mdata_subs_state_to_str(xroad_mdata_subs_state_t val)
3680 {
3681  switch(val)
3682  {
3683  case xroad_mdata_subs_state_unsubscribed:
3684  {
3685  return xroad_str("unsubscribed");
3686  }
3687  case xroad_mdata_subs_state_subscribed:
3688  {
3689  return xroad_str("subscribed");
3690  }
3691  case xroad_mdata_subs_state_awaiting_subs:
3692  {
3693  return xroad_str("awaiting_subs");
3694  }
3695  case xroad_mdata_subs_state_awaiting_unsubs:
3696  {
3697  return xroad_str("awaiting_unsubs");
3698  }
3699  case xroad_mdata_subs_state_deleted:
3700  {
3701  return xroad_str("deleted");
3702  }
3703  default:
3704  {
3705  return xroad_str_null;
3706  }
3707  }
3708 }
3709 
3710 //--------------------------------------------------------------------------------------------------------------------//
3711 static inline xroad_mdata_subs_state_t xroad_mdata_subs_state_from_str(xroad_str_t val)
3712 {
3713  if (!xroad_str_cmp(val, xroad_str("unsubscribed")))
3714  {
3715  return xroad_mdata_subs_state_unsubscribed;
3716  }
3717  if (!xroad_str_cmp(val, xroad_str("subscribed")))
3718  {
3719  return xroad_mdata_subs_state_subscribed;
3720  }
3721  if (!xroad_str_cmp(val, xroad_str("awaiting_subs")))
3722  {
3723  return xroad_mdata_subs_state_awaiting_subs;
3724  }
3725  if (!xroad_str_cmp(val, xroad_str("awaiting_unsubs")))
3726  {
3727  return xroad_mdata_subs_state_awaiting_unsubs;
3728  }
3729  if (!xroad_str_cmp(val, xroad_str("deleted")))
3730  {
3731  return xroad_mdata_subs_state_deleted;
3732  }
3733  return (xroad_mdata_subs_state_t)0;
3734 }
3735 
3736 //--------------------------------------------------------------------------------------------------------------------//
3737 static inline xroad_str_t xroad_mdata_subs_state_get_text(xroad_mdata_subs_state_t val)
3738 {
3739  switch(val)
3740  {
3741  case xroad_mdata_subs_state_unsubscribed:
3742  {
3743  return xroad_str("unsubscribed");
3744  }
3745  case xroad_mdata_subs_state_subscribed:
3746  {
3747  return xroad_str("subscribed");
3748  }
3749  case xroad_mdata_subs_state_awaiting_subs:
3750  {
3751  return xroad_str("awaiting_subs");
3752  }
3753  case xroad_mdata_subs_state_awaiting_unsubs:
3754  {
3755  return xroad_str("awaiting_unsubs");
3756  }
3757  case xroad_mdata_subs_state_deleted:
3758  {
3759  return xroad_str("deleted");
3760  }
3761  default:
3762  {
3763  return xroad_str_null;
3764  }
3765  }
3766 }
3767 
3768 //--------------------------------------------------------------------------------------------------------------------//
3769 static inline xroad_str_t xroad_mdsource_state_to_str(xroad_mdsource_state_t val)
3770 {
3771  switch(val)
3772  {
3773  case xroad_mdsource_state_online:
3774  {
3775  return xroad_str("online");
3776  }
3777  case xroad_mdsource_state_recovery:
3778  {
3779  return xroad_str("recovery");
3780  }
3781  case xroad_mdsource_state_offline:
3782  {
3783  return xroad_str("offline");
3784  }
3785  default:
3786  {
3787  return xroad_str_null;
3788  }
3789  }
3790 }
3791 
3792 //--------------------------------------------------------------------------------------------------------------------//
3793 static inline xroad_mdsource_state_t xroad_mdsource_state_from_str(xroad_str_t val)
3794 {
3795  if (!xroad_str_cmp(val, xroad_str("online")))
3796  {
3797  return xroad_mdsource_state_online;
3798  }
3799  if (!xroad_str_cmp(val, xroad_str("recovery")))
3800  {
3801  return xroad_mdsource_state_recovery;
3802  }
3803  if (!xroad_str_cmp(val, xroad_str("offline")))
3804  {
3805  return xroad_mdsource_state_offline;
3806  }
3807  return (xroad_mdsource_state_t)0;
3808 }
3809 
3810 //--------------------------------------------------------------------------------------------------------------------//
3811 static inline xroad_str_t xroad_mdsource_state_get_text(xroad_mdsource_state_t val)
3812 {
3813  switch(val)
3814  {
3815  case xroad_mdsource_state_online:
3816  {
3817  return xroad_str("online");
3818  }
3819  case xroad_mdsource_state_recovery:
3820  {
3821  return xroad_str("recovery");
3822  }
3823  case xroad_mdsource_state_offline:
3824  {
3825  return xroad_str("offline");
3826  }
3827  default:
3828  {
3829  return xroad_str_null;
3830  }
3831  }
3832 }
3833 
3834 //--------------------------------------------------------------------------------------------------------------------//
3835 static inline xroad_str_t xroad_check_result_to_str(xroad_check_result_t val)
3836 {
3837  switch(val)
3838  {
3839  case xroad_check_result_ok:
3840  {
3841  return xroad_str("ok");
3842  }
3844  {
3845  return xroad_str("failed");
3846  }
3847  default:
3848  {
3849  return xroad_str_null;
3850  }
3851  }
3852 }
3853 
3854 //--------------------------------------------------------------------------------------------------------------------//
3855 static inline xroad_check_result_t xroad_check_result_from_str(xroad_str_t val)
3856 {
3857  if (!xroad_str_cmp(val, xroad_str("ok")))
3858  {
3859  return xroad_check_result_ok;
3860  }
3861  if (!xroad_str_cmp(val, xroad_str("failed")))
3862  {
3864  }
3865  return (xroad_check_result_t)0;
3866 }
3867 
3868 //--------------------------------------------------------------------------------------------------------------------//
3869 static inline xroad_str_t xroad_check_result_get_text(xroad_check_result_t val)
3870 {
3871  switch(val)
3872  {
3873  case xroad_check_result_ok:
3874  {
3875  return xroad_str("ok");
3876  }
3878  {
3879  return xroad_str("failed");
3880  }
3881  default:
3882  {
3883  return xroad_str_null;
3884  }
3885  }
3886 }
3887 
3888 //--------------------------------------------------------------------------------------------------------------------//
3889 static inline xroad_str_t xroad_auct_status_to_str(xroad_auct_status_t val)
3890 {
3891  switch(val)
3892  {
3893  case xroad_auct_status_active:
3894  {
3895  return xroad_str("active");
3896  }
3897  case xroad_auct_status_inactive:
3898  {
3899  return xroad_str("inactive");
3900  }
3901  case xroad_auct_status_completed:
3902  {
3903  return xroad_str("completed");
3904  }
3905  case xroad_auct_status_undefined:
3906  {
3907  return xroad_str("undefined");
3908  }
3909  default:
3910  {
3911  return xroad_str_null;
3912  }
3913  }
3914 }
3915 
3916 //--------------------------------------------------------------------------------------------------------------------//
3917 static inline xroad_auct_status_t xroad_auct_status_from_str(xroad_str_t val)
3918 {
3919  if (!xroad_str_cmp(val, xroad_str("active")))
3920  {
3921  return xroad_auct_status_active;
3922  }
3923  if (!xroad_str_cmp(val, xroad_str("inactive")))
3924  {
3925  return xroad_auct_status_inactive;
3926  }
3927  if (!xroad_str_cmp(val, xroad_str("completed")))
3928  {
3929  return xroad_auct_status_completed;
3930  }
3931  if (!xroad_str_cmp(val, xroad_str("undefined")))
3932  {
3933  return xroad_auct_status_undefined;
3934  }
3935  return (xroad_auct_status_t)0;
3936 }
3937 
3938 //--------------------------------------------------------------------------------------------------------------------//
3939 static inline xroad_str_t xroad_auct_status_get_text(xroad_auct_status_t val)
3940 {
3941  switch(val)
3942  {
3943  case xroad_auct_status_active:
3944  {
3945  return xroad_str("active");
3946  }
3947  case xroad_auct_status_inactive:
3948  {
3949  return xroad_str("inactive");
3950  }
3951  case xroad_auct_status_completed:
3952  {
3953  return xroad_str("completed");
3954  }
3955  case xroad_auct_status_undefined:
3956  {
3957  return xroad_str("undefined");
3958  }
3959  default:
3960  {
3961  return xroad_str_null;
3962  }
3963  }
3964 }
3965 
3966 //--------------------------------------------------------------------------------------------------------------------//
3967 static inline xroad_str_t xroad_trading_session_type_to_str(xroad_trading_session_type_t val)
3968 {
3969  switch(val)
3970  {
3971  case xroad_trading_session_type_opening_auct:
3972  {
3973  return xroad_str("opening_auct");
3974  }
3975  case xroad_trading_session_type_regular:
3976  {
3977  return xroad_str("regular");
3978  }
3979  case xroad_trading_session_type_closing_auct:
3980  {
3981  return xroad_str("closing_auct");
3982  }
3983  case xroad_trading_session_type_after_hours:
3984  {
3985  return xroad_str("after_hours");
3986  }
3987  default:
3988  {
3989  return xroad_str_null;
3990  }
3991  }
3992 }
3993 
3994 //--------------------------------------------------------------------------------------------------------------------//
3995 static inline xroad_trading_session_type_t xroad_trading_session_type_from_str(xroad_str_t val)
3996 {
3997  if (!xroad_str_cmp(val, xroad_str("opening_auct")))
3998  {
3999  return xroad_trading_session_type_opening_auct;
4000  }
4001  if (!xroad_str_cmp(val, xroad_str("regular")))
4002  {
4003  return xroad_trading_session_type_regular;
4004  }
4005  if (!xroad_str_cmp(val, xroad_str("closing_auct")))
4006  {
4007  return xroad_trading_session_type_closing_auct;
4008  }
4009  if (!xroad_str_cmp(val, xroad_str("after_hours")))
4010  {
4011  return xroad_trading_session_type_after_hours;
4012  }
4013  return (xroad_trading_session_type_t)0;
4014 }
4015 
4016 //--------------------------------------------------------------------------------------------------------------------//
4017 static inline xroad_str_t xroad_trading_session_type_get_text(xroad_trading_session_type_t val)
4018 {
4019  switch(val)
4020  {
4021  case xroad_trading_session_type_opening_auct:
4022  {
4023  return xroad_str("opening auction");
4024  }
4025  case xroad_trading_session_type_regular:
4026  {
4027  return xroad_str("regular trading");
4028  }
4029  case xroad_trading_session_type_closing_auct:
4030  {
4031  return xroad_str("closing auction");
4032  }
4033  case xroad_trading_session_type_after_hours:
4034  {
4035  return xroad_str("after hours trading");
4036  }
4037  default:
4038  {
4039  return xroad_str_null;
4040  }
4041  }
4042 }
4043 
4044 //--------------------------------------------------------------------------------------------------------------------//
4045 static inline xroad_str_t xroad_trading_status_to_str(xroad_trading_status_t val)
4046 {
4047  switch(val)
4048  {
4049  case xroad_trading_status_regular_trading:
4050  {
4051  return xroad_str("regular_trading");
4052  }
4053  case xroad_trading_status_opening_period:
4054  {
4055  return xroad_str("opening_period");
4056  }
4057  case xroad_trading_status_closing_period:
4058  {
4059  return xroad_str("closing_period");
4060  }
4061  case xroad_trading_status_opening_auction:
4062  {
4063  return xroad_str("opening_auction");
4064  }
4065  case xroad_trading_status_closing_auction:
4066  {
4067  return xroad_str("closing_auction");
4068  }
4069  case xroad_trading_status_auction:
4070  {
4071  return xroad_str("auction");
4072  }
4073  case xroad_trading_status__reserved1:
4074  {
4075  return xroad_str("_reserved1");
4076  }
4077  case xroad_trading_status_halt:
4078  {
4079  return xroad_str("halt");
4080  }
4081  case xroad_trading_status_closed:
4082  {
4083  return xroad_str("closed");
4084  }
4085  case xroad_trading_status__reserved2:
4086  {
4087  return xroad_str("_reserved2");
4088  }
4089  case xroad_trading_status_unknown:
4090  {
4091  return xroad_str("unknown");
4092  }
4093  default:
4094  {
4095  return xroad_str_null;
4096  }
4097  }
4098 }
4099 
4100 //--------------------------------------------------------------------------------------------------------------------//
4101 static inline xroad_trading_status_t xroad_trading_status_from_str(xroad_str_t val)
4102 {
4103  if (!xroad_str_cmp(val, xroad_str("regular_trading")))
4104  {
4105  return xroad_trading_status_regular_trading;
4106  }
4107  if (!xroad_str_cmp(val, xroad_str("opening_period")))
4108  {
4109  return xroad_trading_status_opening_period;
4110  }
4111  if (!xroad_str_cmp(val, xroad_str("closing_period")))
4112  {
4113  return xroad_trading_status_closing_period;
4114  }
4115  if (!xroad_str_cmp(val, xroad_str("opening_auction")))
4116  {
4117  return xroad_trading_status_opening_auction;
4118  }
4119  if (!xroad_str_cmp(val, xroad_str("closing_auction")))
4120  {
4121  return xroad_trading_status_closing_auction;
4122  }
4123  if (!xroad_str_cmp(val, xroad_str("auction")))
4124  {
4125  return xroad_trading_status_auction;
4126  }
4127  if (!xroad_str_cmp(val, xroad_str("_reserved1")))
4128  {
4129  return xroad_trading_status__reserved1;
4130  }
4131  if (!xroad_str_cmp(val, xroad_str("halt")))
4132  {
4133  return xroad_trading_status_halt;
4134  }
4135  if (!xroad_str_cmp(val, xroad_str("closed")))
4136  {
4137  return xroad_trading_status_closed;
4138  }
4139  if (!xroad_str_cmp(val, xroad_str("_reserved2")))
4140  {
4141  return xroad_trading_status__reserved2;
4142  }
4143  if (!xroad_str_cmp(val, xroad_str("unknown")))
4144  {
4145  return xroad_trading_status_unknown;
4146  }
4147  return (xroad_trading_status_t)0;
4148 }
4149 
4150 //--------------------------------------------------------------------------------------------------------------------//
4151 static inline xroad_str_t xroad_trading_status_get_text(xroad_trading_status_t val)
4152 {
4153  switch(val)
4154  {
4155  case xroad_trading_status_regular_trading:
4156  {
4157  return xroad_str("regular trading");
4158  }
4159  case xroad_trading_status_opening_period:
4160  {
4161  return xroad_str("opening period");
4162  }
4163  case xroad_trading_status_closing_period:
4164  {
4165  return xroad_str("closing period");
4166  }
4167  case xroad_trading_status_opening_auction:
4168  {
4169  return xroad_str("opening auction");
4170  }
4171  case xroad_trading_status_closing_auction:
4172  {
4173  return xroad_str("closing auction");
4174  }
4175  case xroad_trading_status_auction:
4176  {
4177  return xroad_str("auction");
4178  }
4179  case xroad_trading_status__reserved1:
4180  {
4181  return xroad_str("reuse_it_1");
4182  }
4183  case xroad_trading_status_halt:
4184  {
4185  return xroad_str("halt (can not send new but can cancel orders)");
4186  }
4187  case xroad_trading_status_closed:
4188  {
4189  return xroad_str("closed");
4190  }
4191  case xroad_trading_status__reserved2:
4192  {
4193  return xroad_str("reuse_it_2");
4194  }
4195  case xroad_trading_status_unknown:
4196  {
4197  return xroad_str("unknown");
4198  }
4199  default:
4200  {
4201  return xroad_str_null;
4202  }
4203  }
4204 }
4205 
4206 //--------------------------------------------------------------------------------------------------------------------//
4207 static inline xroad_str_t xroad_pre_trade_status_to_str(xroad_pre_trade_status_t val)
4208 {
4209  switch(val)
4210  {
4212  {
4213  return xroad_str("accept");
4214  }
4216  {
4217  return xroad_str("reject");
4218  }
4219  default:
4220  {
4221  return xroad_str_null;
4222  }
4223  }
4224 }
4225 
4226 //--------------------------------------------------------------------------------------------------------------------//
4227 static inline xroad_pre_trade_status_t xroad_pre_trade_status_from_str(xroad_str_t val)
4228 {
4229  if (!xroad_str_cmp(val, xroad_str("accept")))
4230  {
4232  }
4233  if (!xroad_str_cmp(val, xroad_str("reject")))
4234  {
4236  }
4237  return (xroad_pre_trade_status_t)0;
4238 }
4239 
4240 //--------------------------------------------------------------------------------------------------------------------//
4241 static inline xroad_str_t xroad_pre_trade_status_get_text(xroad_pre_trade_status_t val)
4242 {
4243  switch(val)
4244  {
4246  {
4247  return xroad_str("accept");
4248  }
4250  {
4251  return xroad_str("reject");
4252  }
4253  default:
4254  {
4255  return xroad_str_null;
4256  }
4257  }
4258 }
4259 
4260 //--------------------------------------------------------------------------------------------------------------------//
4261 static inline xroad_str_t xroad_prop_flags_to_str(xroad_prop_flags_t val)
4262 {
4263  switch(val)
4264  {
4266  {
4267  return xroad_str("readonly");
4268  }
4270  {
4271  return xroad_str("clone");
4272  }
4273  default:
4274  {
4275  return xroad_str_null;
4276  }
4277  }
4278 }
4279 
4280 //--------------------------------------------------------------------------------------------------------------------//
4281 static inline xroad_prop_flags_t xroad_prop_flags_from_str(xroad_str_t val)
4282 {
4283  if (!xroad_str_cmp(val, xroad_str("readonly")))
4284  {
4286  }
4287  if (!xroad_str_cmp(val, xroad_str("clone")))
4288  {
4289  return xroad_prop_flags_clone;
4290  }
4291  return (xroad_prop_flags_t)0;
4292 }
4293 
4294 //--------------------------------------------------------------------------------------------------------------------//
4295 static inline xroad_str_t xroad_prop_flags_get_text(xroad_prop_flags_t val)
4296 {
4297  switch(val)
4298  {
4300  {
4301  return xroad_str("readonly");
4302  }
4304  {
4305  return xroad_str("clone");
4306  }
4307  default:
4308  {
4309  return xroad_str_null;
4310  }
4311  }
4312 }
4313 
4314 //--------------------------------------------------------------------------------------------------------------------//
4315 static inline xroad_str_t xroad_node_event_enum_to_str(xroad_node_event_enum_t val)
4316 {
4317  switch(val)
4318  {
4320  {
4321  return xroad_str("exited");
4322  }
4324  {
4325  return xroad_str("crashed");
4326  }
4328  {
4329  return xroad_str("added");
4330  }
4332  {
4333  return xroad_str("deleted");
4334  }
4336  {
4337  return xroad_str("renamed");
4338  }
4339  default:
4340  {
4341  return xroad_str_null;
4342  }
4343  }
4344 }
4345 
4346 //--------------------------------------------------------------------------------------------------------------------//
4347 static inline xroad_node_event_enum_t xroad_node_event_enum_from_str(xroad_str_t val)
4348 {
4349  if (!xroad_str_cmp(val, xroad_str("exited")))
4350  {
4352  }
4353  if (!xroad_str_cmp(val, xroad_str("crashed")))
4354  {
4356  }
4357  if (!xroad_str_cmp(val, xroad_str("added")))
4358  {
4360  }
4361  if (!xroad_str_cmp(val, xroad_str("deleted")))
4362  {
4364  }
4365  if (!xroad_str_cmp(val, xroad_str("renamed")))
4366  {
4368  }
4369  return (xroad_node_event_enum_t)0;
4370 }
4371 
4372 //--------------------------------------------------------------------------------------------------------------------//
4373 static inline xroad_str_t xroad_node_event_enum_get_text(xroad_node_event_enum_t val)
4374 {
4375  switch(val)
4376  {
4378  {
4379  return xroad_str("exited");
4380  }
4382  {
4383  return xroad_str("crashed");
4384  }
4386  {
4387  return xroad_str("added");
4388  }
4390  {
4391  return xroad_str("deleted");
4392  }
4394  {
4395  return xroad_str("renamed");
4396  }
4397  default:
4398  {
4399  return xroad_str_null;
4400  }
4401  }
4402 }
4403 
4404 //--------------------------------------------------------------------------------------------------------------------//
4405 static inline xroad_str_t xroad_instr_flags_to_str(xroad_instr_flags_t val)
4406 {
4407  switch(val)
4408  {
4410  {
4411  return xroad_str("not_expand");
4412  }
4413  default:
4414  {
4415  return xroad_str_null;
4416  }
4417  }
4418 }
4419 
4420 //--------------------------------------------------------------------------------------------------------------------//
4421 static inline xroad_instr_flags_t xroad_instr_flags_from_str(xroad_str_t val)
4422 {
4423  if (!xroad_str_cmp(val, xroad_str("not_expand")))
4424  {
4426  }
4427  return (xroad_instr_flags_t)0;
4428 }
4429 
4430 //--------------------------------------------------------------------------------------------------------------------//
4431 static inline xroad_str_t xroad_instr_flags_get_text(xroad_instr_flags_t val)
4432 {
4433  switch(val)
4434  {
4436  {
4437  return xroad_str("not expand");
4438  }
4439  default:
4440  {
4441  return xroad_str_null;
4442  }
4443  }
4444 }
4445 
4446 //--------------------------------------------------------------------------------------------------------------------//
4447 static inline xroad_str_t xroad_mdsource_flags_to_str(xroad_mdsource_flags_t val)
4448 {
4449  switch(val)
4450  {
4452  {
4453  return xroad_str("low_latency");
4454  }
4456  {
4457  return xroad_str("speedway");
4458  }
4459  default:
4460  {
4461  return xroad_str_null;
4462  }
4463  }
4464 }
4465 
4466 //--------------------------------------------------------------------------------------------------------------------//
4467 static inline xroad_mdsource_flags_t xroad_mdsource_flags_from_str(xroad_str_t val)
4468 {
4469  if (!xroad_str_cmp(val, xroad_str("low_latency")))
4470  {
4472  }
4473  if (!xroad_str_cmp(val, xroad_str("speedway")))
4474  {
4476  }
4477  return (xroad_mdsource_flags_t)0;
4478 }
4479 
4480 //--------------------------------------------------------------------------------------------------------------------//
4481 static inline xroad_str_t xroad_mdsource_flags_get_text(xroad_mdsource_flags_t val)
4482 {
4483  switch(val)
4484  {
4486  {
4487  return xroad_str("low latency");
4488  }
4490  {
4491  return xroad_str("speedway");
4492  }
4493  default:
4494  {
4495  return xroad_str_null;
4496  }
4497  }
4498 }
4499 
4500 
4501 #ifdef __cplusplus
4502 }
4503 #endif
Definition: xroad_objects_types.h:130
Definition: xroad_string.h:29
#define XROAD_CFI_SIZE
Definition: xroad_objects_types.h:199
xroad_instr_flags_t
Definition: xroad_objects_types.h:540
@ xroad_instr_flags_not_expand
do not expand basket
Definition: xroad_objects_types.h:541
#define XROAD_NAME_SIZE
Definition: xroad_objects_types.h:187
#define XROAD_ALIAS_SIZE
Definition: xroad_objects_types.h:193
xroad_prop_flags_t
Definition: xroad_objects_types.h:522
@ xroad_prop_flags_readonly
property can only be changed by owner
Definition: xroad_objects_types.h:523
@ xroad_prop_flags_clone
property can be cloned
Definition: xroad_objects_types.h:524
xroad_node_event_enum_t
Definition: xroad_objects_types.h:528
@ xroad_node_event_enum_renamed
node renamed
Definition: xroad_objects_types.h:533
@ xroad_node_event_enum_added
node added
Definition: xroad_objects_types.h:531
@ xroad_node_event_enum_deleted
node deleted
Definition: xroad_objects_types.h:532
@ xroad_node_event_enum_exited
node exited
Definition: xroad_objects_types.h:529
@ xroad_node_event_enum_crashed
node crashed
Definition: xroad_objects_types.h:530
xroad_mdsource_flags_t
Definition: xroad_objects_types.h:548
@ xroad_mdsource_flags_low_latency
low latency mdsource
Definition: xroad_objects_types.h:549
@ xroad_mdsource_flags_speedway
speedway mdsource
Definition: xroad_objects_types.h:550
xroad_ord_type_t
Definition: xroad_objects_types.h:254
@ xroad_ord_type_limit
limit order
Definition: xroad_objects_types.h:256
@ xroad_ord_type_stop_limit
stop limit order
Definition: xroad_objects_types.h:257
@ xroad_ord_type_market
market orer
Definition: xroad_objects_types.h:255
xroad_order_flags_t
Definition: xroad_objects_types.h:264
@ xroad_order_flags_one_triggers_other
fill for first order triggers others to activate
Definition: xroad_objects_types.h:267
@ xroad_order_flags_test
test order
Definition: xroad_objects_types.h:276
@ xroad_order_flags_from_mmaker
order from market maker
Definition: xroad_objects_types.h:265
@ xroad_order_flags_manual
manual placed order
Definition: xroad_objects_types.h:286
@ xroad_order_flags_warm_up
order for warming up system
Definition: xroad_objects_types.h:274
@ xroad_order_flags_parent
order is parent
Definition: xroad_objects_types.h:285
@ xroad_order_flags_reduce_only
do not increase position
Definition: xroad_objects_types.h:277
@ xroad_order_flags_all_or_none
fully executed or canceled for hidden orders (display_qty: 0) only
Definition: xroad_objects_types.h:268
@ xroad_order_flags_quote
order is quote
Definition: xroad_objects_types.h:283
@ xroad_order_flags_participate_only
doesn't allow execution at placement of new order
Definition: xroad_objects_types.h:266
@ xroad_order_flags_transit
transit order (passed from one system to another)
Definition: xroad_objects_types.h:284
int64_t xroad_qty_t
Definition: xroad_objects_types.h:159
xroad_check_result_t
Definition: xroad_objects_types.h:479
@ xroad_check_result_failed
failed
Definition: xroad_objects_types.h:481
@ xroad_check_result_ok
ok
Definition: xroad_objects_types.h:480
xroad_pre_trade_status_t
Definition: xroad_objects_types.h:516
@ xroad_pre_trade_status_accept
accept pre_trade
Definition: xroad_objects_types.h:517
@ xroad_pre_trade_status_reject
reject pre_trade
Definition: xroad_objects_types.h:518
#define xroad_str_decl(name, sz)
Definition: xroad_string.h:267
#define xroad_str_null
Definition: xroad_string.h:142
#define xroad_str(str)
Definition: xroad_string.h:165
#define xroad_str_cmp(a, b)
Definition: xroad_string.h:90