OnixS C++ eSpeed ITCH Market Data Handler  1.7.3
API documentation
Enumerations.h
Go to the documentation of this file.
1 /*
2 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
3 *
4 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
5 * and international copyright treaties.
6 *
7 * Access to and use of the software is governed by the terms of the applicable ONIXS Software
8 * Services Agreement (the Agreement) and Customer end user license agreements granting
9 * a non-assignable, non-transferable and non-exclusive license to use the software
10 * for it's own data processing purposes under the terms defined in the Agreement.
11 *
12 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
13 * of this source code or associated reference material to any other location for further reproduction
14 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
15 *
16 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
17 * the terms of the Agreement is a violation of copyright law.
18 */
19 
20 #pragma once
21 
22 #include <string>
23 
25 
27 
28 
29  /// Message type enumeration
30  struct MessageType
31  {
32  /// Integral type used as basement for constants.
33  typedef UInt8 Base;
34 
35  enum Enum
36  {
37  ///
39 
40  ///
42 
43  ///
44  SystemEvent = 'S',
45 
46  ///
48 
49  ///
50  AddOrder = 'A',
51 
52  ///
54 
55  ///
57 
58  ///
59  OrderCancel = 'X',
60 
61  ///
62  Trade = 'P',
63 
64  ///
66 
67  ///
68  Information = 'Q',
69 
70  ///
71  BrokenTrade = 'B',
72 
73  };
74  };
75 
76  /// Appends string presentation of object.
77  ONIXS_ESPEED_ITCH_API void toStr(std::string&, MessageType::Enum);
78 
79  /// Returns string presentation of object.
80  inline std::string toStr(MessageType::Enum value)
81  {
82  std::string str;
83  toStr(str, value);
84  return str;
85  }
86 
87  /// System Event Codes
89  {
90  /// Integral type used as basement for constants.
91  typedef UInt8 Base;
92 
93  enum Enum
94  {
95  ///
96  StartOfMessages = 'O',
97 
98  ///
99  StartOfTradingSessionHours = 'Q',
100 
101  ///
102  EndOfTradingSessionHours = 'M',
103 
104  ///
105  EndOfMessages = 'C',
106 
107  };
108  };
109 
110  /// Appends string presentation of object.
111  ONIXS_ESPEED_ITCH_API void toStr(std::string&, SystemEventCode::Enum);
112 
113  /// Returns string presentation of object.
114  inline std::string toStr(SystemEventCode::Enum value)
115  {
116  std::string str;
117  toStr(str, value);
118  return str;
119  }
120 
121  /// System Event Reasons
123  {
124  /// Integral type used as basement for constants.
125  typedef UInt8 Base;
126 
127  enum Enum
128  {
129  ///
130  AcceptingHolidaySessionStarts = 'I',
131 
132  ///
133  Break = 'A',
134 
135  ///
136  ResumptionAfterBreak = 'B',
137 
138  ///
139  EarlyClose = 'H',
140 
141  ///
142  RegularStartOrEnd = 'R',
143 
144  };
145  };
146 
147  /// Appends string presentation of object.
148  ONIXS_ESPEED_ITCH_API void toStr(std::string&, SystemEventReason::Enum);
149 
150  /// Returns string presentation of object.
151  inline std::string toStr(SystemEventReason::Enum value)
152  {
153  std::string str;
154  toStr(str, value);
155  return str;
156  }
157 
158  /// Security Event Codes
160  {
161  /// Integral type used as basement for constants.
162  typedef UInt8 Base;
163 
164  enum Enum
165  {
166  ///
167  Enabled = 'O',
168 
169  ///
170  Disabled = 'M',
171 
172  ///
173  Halted = 'H',
174 
175  };
176  };
177 
178  /// Appends string presentation of object.
179  ONIXS_ESPEED_ITCH_API void toStr(std::string&, SecurityEventCode::Enum);
180 
181  /// Returns string presentation of object.
182  inline std::string toStr(SecurityEventCode::Enum value)
183  {
184  std::string str;
185  toStr(str, value);
186  return str;
187  }
188 
189  /// Product Types
190  struct ProductType
191  {
192  /// Integral type used as basement for constants.
193  typedef UInt8 Base;
194 
195  enum Enum
196  {
197  ///
198  USTreasury = 1,
199 
200  ///
201  USTreasuryBills = 2,
202 
203  ///
204  Reserved3 = 3,
205 
206  ///
207  TIPS = 4,
208 
209  ///
210  Reserved5 = 5,
211 
212  ///
213  CurveOrButterflies = 6,
214 
215  };
216  };
217 
218  /// Appends string presentation of object.
219  ONIXS_ESPEED_ITCH_API void toStr(std::string&, ProductType::Enum);
220 
221  /// Returns string presentation of object.
222  inline std::string toStr(ProductType::Enum value)
223  {
224  std::string str;
225  toStr(str, value);
226  return str;
227  }
228 
229  /// Product Syb Types
231  {
232  /// Integral type used as basement for constants.
233  typedef UInt8 Base;
234 
235  enum Enum
236  {
237  ///
238  Benchmark = 1,
239 
240  ///
241  OffTheRun = 2,
242 
243  ///
244  WI = 3,
245 
246  };
247  };
248 
249  /// Appends string presentation of object.
250  ONIXS_ESPEED_ITCH_API void toStr(std::string&, ProductSubType::Enum);
251 
252  /// Returns string presentation of object.
253  inline std::string toStr(ProductSubType::Enum value)
254  {
255  std::string str;
256  toStr(str, value);
257  return str;
258  }
259 
260  /// Price Types
261  struct PriceType
262  {
263  /// Integral type used as basement for constants.
264  typedef UInt8 Base;
265 
266  enum Enum
267  {
268  ///
269  PerUnit = 'D',
270 
271  ///
272  AsPercentage = 'Y',
273 
274  ///
275  YieldSpread = 'B',
276 
277  };
278  };
279 
280  /// Appends string presentation of object.
281  ONIXS_ESPEED_ITCH_API void toStr(std::string&, PriceType::Enum);
282 
283  /// Returns string presentation of object.
284  inline std::string toStr(PriceType::Enum value)
285  {
286  std::string str;
287  toStr(str, value);
288  return str;
289  }
290 
291  /// Trading Features
293  {
294  /// Integral type used as basement for constants.
295  typedef UInt16 Base;
296 
297  enum Enum
298  {
299  ///
300  Reserved1 = 0x0001,
301 
302  ///
303  SecuritySupportsImpliedTradingThroughLegs = 0x0002,
304 
305  ///
306  IndicativeMarketsSupported = 0x0004,
307 
308  ///
309  Reserved2 = 0x0008,
310 
311  ///
312  TestSecurity = 0x8000,
313 
314  ///
315  NonTradableSecurity = 0x4000,
316 
317  };
318  };
319 
320  /// Appends string presentation of object.
321  ONIXS_ESPEED_ITCH_API void toStr(std::string&, TradingFeatures::Enum);
322 
323  /// Returns string presentation of object.
324  inline std::string toStr(TradingFeatures::Enum value)
325  {
326  std::string str;
327  toStr(str, value);
328  return str;
329  }
330 
331  /// Leg Sides
332  struct LegSide
333  {
334  /// Integral type used as basement for constants.
335  typedef UInt8 Base;
336 
337  enum Enum
338  {
339  ///
340  Undefined = ' ',
341 
342  ///
343  AsDefined = 'B',
344 
345  ///
346  Opposite = 'C',
347 
348  ///
349  LockPriceForTreasurySwap = 'L',
350 
351  };
352  };
353 
354  /// Appends string presentation of object.
355  ONIXS_ESPEED_ITCH_API void toStr(std::string&, LegSide::Enum);
356 
357  /// Returns string presentation of object.
358  inline std::string toStr(LegSide::Enum value)
359  {
360  std::string str;
361  toStr(str, value);
362  return str;
363  }
364 
365  /// Sides
366  struct Side
367  {
368  /// Integral type used as basement for constants.
369  typedef UInt8 Base;
370 
371  enum Enum
372  {
373  ///
374  Buy = 'B',
375 
376  ///
377  Sell = 'S',
378 
379  };
380  };
381 
382  /// Appends string presentation of object.
383  ONIXS_ESPEED_ITCH_API void toStr(std::string&, Side::Enum);
384 
385  /// Returns string presentation of object.
386  inline std::string toStr(Side::Enum value)
387  {
388  std::string str;
389  toStr(str, value);
390  return str;
391  }
392 
393  /// Printable
394  struct Printable
395  {
396  /// Integral type used as basement for constants.
397  typedef UInt8 Base;
398 
399  enum Enum
400  {
401  ///
402  No = 'N',
403 
404  ///
405  Yes = 'Y',
406 
407  };
408  };
409 
410  /// Appends string presentation of object.
411  ONIXS_ESPEED_ITCH_API void toStr(std::string&, Printable::Enum);
412 
413  /// Returns string presentation of object.
414  inline std::string toStr(Printable::Enum value)
415  {
416  std::string str;
417  toStr(str, value);
418  return str;
419  }
420 
421  /// IssuedAsBenchmark
423  {
424  /// Integral type used as basement for constants.
425  typedef UInt16 Base;
426 
427  enum Enum
428  {
429  ///
430  Undefined = 0,
431 
432  ///
433  Issued1M = 1,
434 
435  ///
436  Issued2M = 2,
437 
438  ///
439  Issued3M = 3,
440 
441  ///
442  Issued6M = 6,
443 
444  ///
445  Issued12M = 12,
446 
447  ///
448  Issued2Y = 102,
449 
450  ///
451  Issued3Y = 103,
452 
453  ///
454  Issued5Y = 105,
455 
456  ///
457  Issued7Y = 107,
458 
459  ///
460  Issued10Y = 110,
461 
462  ///
463  Issued20Y = 120,
464 
465  ///
466  Issued30Y = 130,
467 
468  };
469  };
470 
471  /// Appends string presentation of object.
472  ONIXS_ESPEED_ITCH_API void toStr(std::string&, IssuedAsBenchmark::Enum);
473 
474  /// Returns string presentation of object.
475  inline std::string toStr(IssuedAsBenchmark::Enum value)
476  {
477  std::string str;
478  toStr(str, value);
479  return str;
480  }
481 
#define ONIXS_ESPEED_ITCH_NAMESPACE_END
Definition: Bootstrap.h:31
#define ONIXS_ESPEED_ITCH_NAMESPACE_BEGIN
Definition: Bootstrap.h:27
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:193
IssuedAsBenchmark.
Definition: Enumerations.h:422
System Event Reasons.
Definition: Enumerations.h:122
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:233
Sides.
Definition: Enumerations.h:366
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:264
Message type enumeration.
Definition: Enumerations.h:30
System Event Codes.
Definition: Enumerations.h:88
Price Types.
Definition: Enumerations.h:261
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:162
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:125
Trading Features.
Definition: Enumerations.h:292
Product Syb Types.
Definition: Enumerations.h:230
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:91
Product Types.
Definition: Enumerations.h:190
UInt16 Base
Integral type used as basement for constants.
Definition: Enumerations.h:295
UInt16 Base
Integral type used as basement for constants.
Definition: Enumerations.h:425
ONIXS_ESPEED_ITCH_API void toStr(std::string &, MessageType::Enum)
Appends string presentation of object.
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:33
Printable.
Definition: Enumerations.h:394
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:397
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:335
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:369
Leg Sides.
Definition: Enumerations.h:332
Security Event Codes.
Definition: Enumerations.h:159