OnixS C++ EuroTLX GTP Market Data Handler  1.4.0
API documentation
Enumerations.h
Go to the documentation of this file.
1 #pragma once
2 /*
3 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
4 *
5 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
6 * and international copyright treaties.
7 *
8 * Access to and use of the software is governed by the terms of the applicable ONIXS Software
9 * Services Agreement (the Agreement) and Customer end user license agreements granting
10 * a non-assignable, non-transferable and non-exclusive license to use the software
11 * for it's own data processing purposes under the terms defined in the Agreement.
12 *
13 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
14 * of this source code or associated reference material to any other location for further reproduction
15 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
16 *
17 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
18 * the terms of the Agreement is a violation of copyright law.
19 */
20 #include <string>
21 
23 
24 
25 namespace OnixS {
26 namespace EuroTLX {
27 namespace MarketData {
28 namespace GTP {
29 
30 
31  /// EventCode
32  struct EventCode
33  {
34  /// Integral type used as basement for constants.
35  typedef Byte Base;
36 
37  enum Enum
38  {
39  ///
40  EndOfDay = 'C',
41 
42  ///
43  StartOfDay = 'O',
44 
45  ///
46  StartOfOpen = 'T',
47 
48  ///
50 
51  };
52  };
53 
54  /// Appends string presentation of object.
55  ONIXS_EUROTLX_GTP_API void toStr(std::string&, EventCode::Enum);
56 
57  /// Returns string presentation of object.
58  inline std::string toStr(EventCode::Enum value)
59  {
60  std::string str;
61  toStr(str, value);
62  return str;
63  }
64 
65  /// SettlementSystem
67  {
68  /// Integral type used as basement for constants.
69  typedef UInt8 Base;
70 
71  enum Enum
72  {
73  ///
74  RRG = 1,
75 
76  ///
77  ExpressI = 2,
78 
79  ///
80  ExpressII = 3,
81 
82  ///
83  Clearstream = 4,
84 
85  ///
86  Undefinedvalue = 5,
87 
88  ///
89  T2S = 6,
90 
91  };
92  };
93 
94  /// Appends string presentation of object.
95  ONIXS_EUROTLX_GTP_API void toStr(std::string&, SettlementSystem::Enum);
96 
97  /// Returns string presentation of object.
98  inline std::string toStr(SettlementSystem::Enum value)
99  {
100  std::string str;
101  toStr(str, value);
102  return str;
103  }
104 
105  /// ClearingType
107  {
108  /// Integral type used as basement for constants.
109  typedef UInt8 Base;
110 
111  enum Enum
112  {
113  ///
114  NotCleared = 0,
115 
116  ///
117  Cleared = 1,
118 
119  };
120  };
121 
122  /// Appends string presentation of object.
123  ONIXS_EUROTLX_GTP_API void toStr(std::string&, ClearingType::Enum);
124 
125  /// Returns string presentation of object.
126  inline std::string toStr(ClearingType::Enum value)
127  {
128  std::string str;
129  toStr(str, value);
130  return str;
131  }
132 
133  /// UnderlyingType
135  {
136  /// Integral type used as basement for constants.
137  typedef UInt8 Base;
138 
139  enum Enum
140  {
141  ///
142  UnderlyingTypeIsNotCodifiedInBasicData = 0,
143 
144  ///
145  Share = 1,
146 
147  ///
148  ForeignCurrency = 2,
149 
150  ///
151  Indices = 3,
152 
153  ///
154  Commodity = 4,
155 
156  ///
157  ForeignIndices = 5,
158 
159  ///
160  Future = 6,
161 
162  ///
163  ForeignShare = 7,
164 
165  ///
166  Basket = 8,
167 
168  ///
169  ExchangeRate = 9,
170 
171  };
172  };
173 
174  /// Appends string presentation of object.
175  ONIXS_EUROTLX_GTP_API void toStr(std::string&, UnderlyingType::Enum);
176 
177  /// Returns string presentation of object.
178  inline std::string toStr(UnderlyingType::Enum value)
179  {
180  std::string str;
181  toStr(str, value);
182  return str;
183  }
184 
185  /// InstrumentOptionStyle
187  {
188  /// Integral type used as basement for constants.
189  typedef Byte Base;
190 
191  enum Enum
192  {
193  ///
194  EuropeanOptionStyle = 'E',
195 
196  ///
197  AmericanOptionStyle = 'A',
198 
199  ///
200  PeriodicOptionStyle = 'P',
201 
202  };
203  };
204 
205  /// Appends string presentation of object.
206  ONIXS_EUROTLX_GTP_API void toStr(std::string&, InstrumentOptionStyle::Enum);
207 
208  /// Returns string presentation of object.
209  inline std::string toStr(InstrumentOptionStyle::Enum value)
210  {
211  std::string str;
212  toStr(str, value);
213  return str;
214  }
215 
216  /// DirtyCleanPrice
218  {
219  /// Integral type used as basement for constants.
220  typedef Byte Base;
221 
222  enum Enum
223  {
224  ///
225  Unspecified = 0,
226 
227  ///
228  Secco = 1,
229 
230  ///
231  TelQuel = 2,
232 
233  };
234  };
235 
236  /// Appends string presentation of object.
237  ONIXS_EUROTLX_GTP_API void toStr(std::string&, DirtyCleanPrice::Enum);
238 
239  /// Returns string presentation of object.
240  inline std::string toStr(DirtyCleanPrice::Enum value)
241  {
242  std::string str;
243  toStr(str, value);
244  return str;
245  }
246 
247  /// GrossSettlementIndicator
249  {
250  /// Integral type used as basement for constants.
251  typedef Byte Base;
252 
253  enum Enum
254  {
255  ///
256  GrossSettlement = 'Y',
257 
258  ///
259  NetNonGrossSettlement1 = 'N',
260 
261  ///
262  NetNonGrossSettlement2 = ' ',
263 
264  };
265  };
266 
267  /// Appends string presentation of object.
268  ONIXS_EUROTLX_GTP_API void toStr(std::string&, GrossSettlementIndicator::Enum);
269 
270  /// Returns string presentation of object.
271  inline std::string toStr(GrossSettlementIndicator::Enum value)
272  {
273  std::string str;
274  toStr(str, value);
275  return str;
276  }
277 
278  /// InverseOrderbook
280  {
281  /// Integral type used as basement for constants.
282  typedef Byte Base;
283 
284  enum Enum
285  {
286  ///
287  No = 0,
288 
289  ///
290  Yes = 1,
291 
292  };
293  };
294 
295  /// Appends string presentation of object.
296  ONIXS_EUROTLX_GTP_API void toStr(std::string&, InverseOrderbook::Enum);
297 
298  /// Returns string presentation of object.
299  inline std::string toStr(InverseOrderbook::Enum value)
300  {
301  std::string str;
302  toStr(str, value);
303  return str;
304  }
305 
306  /// SessionChangeReason
308  {
309  /// Integral type used as basement for constants.
310  typedef Byte Base;
311 
312  enum Enum
313  {
314  ///
315  ScheduledTransition = 0,
316 
317  ///
318  ExtendedbyMarketOps = 1,
319 
320  ///
321  ShortenedbyMarketOps = 2,
322 
323  ///
324  MarketOrderImbalance = 3,
325 
326  ///
327  PriceOutsideRange = 4,
328 
329  ///
330  AespCircuitBreakerTripped = 5,
331 
332  ///
333  SpecialistNotPresent = 6,
334 
335  ///
336  Unavailable = 9,
337 
338  };
339  };
340 
341  /// Appends string presentation of object.
342  ONIXS_EUROTLX_GTP_API void toStr(std::string&, SessionChangeReason::Enum);
343 
344  /// Returns string presentation of object.
345  inline std::string toStr(SessionChangeReason::Enum value)
346  {
347  std::string str;
348  toStr(str, value);
349  return str;
350  }
351 
352  /// Side
353  struct Side
354  {
355  /// Integral type used as basement for constants.
356  typedef Byte Base;
357 
358  enum Enum
359  {
360  ///
361  BuyOrder = 'B',
362 
363  ///
364  SellOrder = 'S',
365 
366  };
367  };
368 
369  /// Appends string presentation of object.
370  ONIXS_EUROTLX_GTP_API void toStr(std::string&, Side::Enum);
371 
372  /// Returns string presentation of object.
373  inline std::string toStr(Side::Enum value)
374  {
375  std::string str;
376  toStr(str, value);
377  return str;
378  }
379 
380  /// OrderType
381  struct OrderType
382  {
383  /// Integral type used as basement for constants.
384  typedef UInt8 Base;
385 
386  enum Enum
387  {
388  ///
389  LimitOrderFirmQuote = 0,
390 
391  ///
392  MarketOrder = 1,
393 
394  ///
395  ImpliedOrder = 2,
396 
397  ///
398  NamedLimit = 3,
399 
400  ///
401  NamedMarket = 4,
402 
403  ///
404  ExecutableQuotes = 5,
405 
406  };
407  };
408 
409  /// Appends string presentation of object.
410  ONIXS_EUROTLX_GTP_API void toStr(std::string&, OrderType::Enum);
411 
412  /// Returns string presentation of object.
413  inline std::string toStr(OrderType::Enum value)
414  {
415  std::string str;
416  toStr(str, value);
417  return str;
418  }
419 
420  /// TradeType
421  struct TradeType
422  {
423  /// Integral type used as basement for constants.
424  typedef UInt8 Base;
425 
426  enum Enum
427  {
428  ///
429  RegularTrade = 0,
430 
431  ///
432  AuctionTradeBulk = 1,
433 
434  ///
435  AuctionTradeIndividual = 2,
436 
437  ///
438  LateTrade = 5,
439 
440  ///
441  Reserve = 8,
442 
443  ///
444  TradeCancellation = 9,
445 
446  ///
447  StrategyVsStrategyTrade = 10,
448 
449  ///
450  TradeCorrection = 11,
451 
452  ///
453  RfqTrade = 22,
454 
455  ///
456  RfqTradeCancellation = 23,
457 
458  ///
459  RfqTradeCorrection = 24,
460 
461  ///
462  CrossCPITrade = 25,
463 
464  ///
465  CPITrade = 26,
466 
467  };
468  };
469 
470  /// Appends string presentation of object.
471  ONIXS_EUROTLX_GTP_API void toStr(std::string&, TradeType::Enum);
472 
473  /// Returns string presentation of object.
474  inline std::string toStr(TradeType::Enum value)
475  {
476  std::string str;
477  toStr(str, value);
478  return str;
479  }
480 
481  /// TradeQualifier
483  {
484  /// Integral type used as basement for constants.
485  typedef Byte Base;
486 
487  enum Enum
488  {
489  ///
490  ClosingPriceCross = 'C',
491 
492  ///
493  TradeAtLast = 'T',
494 
495  ///
496  NotApplicable = ' ',
497 
498  };
499  };
500 
501  /// Appends string presentation of object.
502  ONIXS_EUROTLX_GTP_API void toStr(std::string&, TradeQualifier::Enum);
503 
504  /// Returns string presentation of object.
505  inline std::string toStr(TradeQualifier::Enum value)
506  {
507  std::string str;
508  toStr(str, value);
509  return str;
510  }
511 
512  /// AuctionType
513  struct AuctionType
514  {
515  /// Integral type used as basement for constants.
516  typedef Byte Base;
517 
518  enum Enum
519  {
520  ///
521  Undefined = 0,
522 
523  ///
524  ClosingAuction = 'C',
525 
526  ///
527  OpeningAuction = '0',
528 
529  ///
530  AESP = 'A',
531 
532  ///
533  EDSP = 'B',
534 
535  ///
536  OPA = 'P',
537 
538  ///
539  ResumeAuction = 'E',
540 
541  ///
542  PeriodicAuction = 'F',
543 
544  ///
545  IntradayLevel1Auction = 'G',
546 
547  ///
548  FrequentLitAuctions = 'L',
549 
550  };
551  };
552 
553  /// Appends string presentation of object.
554  ONIXS_EUROTLX_GTP_API void toStr(std::string&, AuctionType::Enum);
555 
556  /// Returns string presentation of object.
557  inline std::string toStr(AuctionType::Enum value)
558  {
559  std::string str;
560  toStr(str, value);
561  return str;
562  }
563 
564  /// StatisticType
566  {
567  /// Integral type used as basement for constants.
568  typedef UInt16 Base;
569 
570  enum Enum
571  {
572  ///
573  IndicativeAuctionUncrossingData = 1,
574 
575  ///
576  OfficialOpeningPrice = 2,
577 
578  ///
579  OfficialClosingPrice = 3,
580 
581  ///
582  TradeHighOnBook = 4,
583 
584  ///
585  TradeLowOnBook = 5,
586 
587  ///
588  TradeHighAllTrades = 6,
589 
590  ///
591  TradeLowAllTrades = 7,
592 
593  ///
594  Week52TradeHighAllTrades = 8,
595 
596  ///
597  Week52TradeLowAllTrades = 9,
598 
599  ///
600  BestClosingBid = 10,
601 
602  ///
603  BestClosingAsk = 11,
604 
605  ///
606  TradeHighOffBook = 12,
607 
608  ///
609  TradeLowOffBook = 13,
610 
611  ///
612  OpenInterest = 14,
613 
614  ///
615  Volatility = 15,
616 
617  ///
618  StaticReferencePrice = 16,
619 
620  ///
621  DynamicReferencePrice = 17,
622 
623  ///
624  PBBOMidpointPriceWFMCsHavePassed3 = 18,
625 
626  ///
627  PBBOMidpointPriceWFMCsHaveFailed3 = 19,
628 
629  };
630  };
631 
632  /// Appends string presentation of object.
633  ONIXS_EUROTLX_GTP_API void toStr(std::string&, StatisticType::Enum);
634 
635  /// Returns string presentation of object.
636  inline std::string toStr(StatisticType::Enum value)
637  {
638  std::string str;
639  toStr(str, value);
640  return str;
641  }
642 
643  /// AuctionInfo
644  struct AuctionInfo
645  {
646  /// Integral type used as basement for constants.
647  typedef Byte Base;
648 
649  enum Enum
650  {
651  ///
652  Undefined = 0,
653 
654  ///
655  BuyImbalance = 'B',
656 
657  ///
658  NoImbalance = 'N',
659 
660  ///
661  InsufficientOrdersforAuction = 'O',
662 
663  ///
664  SellImbalance = 'S',
665 
666  ///
667  CallMarket = 'M',
668 
669  };
670  };
671 
672  /// Appends string presentation of object.
673  ONIXS_EUROTLX_GTP_API void toStr(std::string&, AuctionInfo::Enum);
674 
675  /// Returns string presentation of object.
676  inline std::string toStr(AuctionInfo::Enum value)
677  {
678  std::string str;
679  toStr(str, value);
680  return str;
681  }
682 
683  /// AnnouncementType
685  {
686  /// Integral type used as basement for constants.
687  typedef Byte Base;
688 
689  enum Enum
690  {
691  ///
692  Regular = '0',
693 
694  ///
695  HighPriority = '1',
696 
697  ///
698  LowPriority = '2',
699 
700  ///
701  StressedMarketConditionStart = '3',
702 
703  ///
704  StressedMarketConditionEnd = '4',
705 
706  ///
707  StressedMarketObligationsStart = '5',
708 
709  ///
710  StressedMarketObligationsEnd = '6',
711 
712  };
713  };
714 
715  /// Appends string presentation of object.
716  ONIXS_EUROTLX_GTP_API void toStr(std::string&, AnnouncementType::Enum);
717 
718  /// Returns string presentation of object.
719  inline std::string toStr(AnnouncementType::Enum value)
720  {
721  std::string str;
722  toStr(str, value);
723  return str;
724  }
725 
726  /// OrderBookType
728  {
729  /// Integral type used as basement for constants.
730  typedef UInt8 Base;
731 
732  enum Enum
733  {
734  ///
735  AllBooks = 0,
736 
737  ///
738  FirmQuote = 1,
739 
740  ///
741  OffBook = 2,
742 
743  ///
744  Electronic = 3,
745 
746  ///
747  PrivateRFQ = 4,
748 
749  };
750  };
751 
752  /// Appends string presentation of object.
753  ONIXS_EUROTLX_GTP_API void toStr(std::string&, OrderBookType::Enum);
754 
755  /// Returns string presentation of object.
756  inline std::string toStr(OrderBookType::Enum value)
757  {
758  std::string str;
759  toStr(str, value);
760  return str;
761  }
762 
763  /// SourceVenue
764  struct SourceVenue
765  {
766  /// Integral type used as basement for constants.
767  typedef UInt16 Base;
768 
769  enum Enum
770  {
771  ///
772  LondonStockExchange = 1,
773 
774  ///
775  BorsaItalianaAndEuroTlxCashEquitiesAndFixedIncome = 2,
776 
777  ///
778  BorsaItalianaDerivatives = 3,
779 
780  ///
781  TurquoiseLit = 5,
782 
783  ///
784  TurquoisePlato = 6,
785 
786  ///
787  BorsaItalianaTradingAfterHours = 8,
788 
789  ///
790  TRADEcho = 11,
791 
792  ///
793  TurquoisePlatoLitAuctions = 12,
794 
795  ///
796  ReservedForFutureUse = 13,
797 
798  ///
799  TurquoiseLitOrderBookTGHE = 14,
800 
801  ///
802  TurquoisePlatoOrderBookTGHE = 15,
803 
804  ///
805  TurquoisePlatoLitAuctionsOrderBookTGHE = 16,
806 
807  };
808  };
809 
810  /// Appends string presentation of object.
811  ONIXS_EUROTLX_GTP_API void toStr(std::string&, SourceVenue::Enum);
812 
813  /// Returns string presentation of object.
814  inline std::string toStr(SourceVenue::Enum value)
815  {
816  std::string str;
817  toStr(str, value);
818  return str;
819  }
820 
821  /// TradingStatus
823  {
824  /// Integral type used as basement for constants.
825  typedef Byte Base;
826 
827  enum Enum
828  {
829  ///
830  None = 0,
831 
832  ///
833  Halt = 'H',
834 
835  ///
836  HaltMatchingPartitionSuspended = 'J',
837 
838  ///
839  HaltSystemSuspended = 'K',
840 
841  ///
842  HaltRegulatoryHalt = 'P',
843 
844  ///
845  HaltInstrumentLevelCircuitBreakerTripped = 'L',
846 
847  ///
848  RegularTradingStartTradeReporting = 'T',
849 
850  ///
851  ResumeOrderDeletionPeriod = 'R',
852 
853  ///
854  TradingStop = 'S',
855 
856  ///
857  PostClose = 'b',
858 
859  ///
860  MarketClosed = 'c',
861 
862  ///
863  NoActiveSession = 'w',
864 
865  ///
866  EndOfPostClose = 'x',
867 
868  ///
869  PreTrading = 'y',
870 
871  ///
872  ClosingPricePublication = 'z',
873 
874  ///
875  QuotingPeriod = 'Q',
876 
877  ///
878  InactiveUnderlyingSuspended = '1',
879 
880  ///
881  Suspended = '2',
882 
883  };
884  };
885 
886  /// Appends string presentation of object.
887  ONIXS_EUROTLX_GTP_API void toStr(std::string&, TradingStatus::Enum);
888 
889  /// Returns string presentation of object.
890  inline std::string toStr(TradingStatus::Enum value)
891  {
892  std::string str;
893  toStr(str, value);
894  return str;
895  }
896 
897  /// ImbalanceDirection
899  {
900  /// Integral type used as basement for constants.
901  typedef Byte Base;
902 
903  enum Enum
904  {
905  ///
906  BuyImbalance = 'B',
907 
908  ///
909  NoImbalance = 'N',
910 
911  ///
912  InsufficientOrdersForAuction = 'O',
913 
914  ///
915  SellImbalance = 'S',
916 
917  };
918  };
919 
920  /// Appends string presentation of object.
921  ONIXS_EUROTLX_GTP_API void toStr(std::string&, ImbalanceDirection::Enum);
922 
923  /// Returns string presentation of object.
924  inline std::string toStr(ImbalanceDirection::Enum value)
925  {
926  std::string str;
927  toStr(str, value);
928  return str;
929  }
930 
931  /// HiddenExecutionIndicator
933  {
934  /// Integral type used as basement for constants.
935  typedef UInt8 Base;
936 
937  enum Enum
938  {
939  ///
940  NotApplicable = 0,
941 
942  ///
943  Visible = 1,
944 
945  ///
946  Hidden = 2,
947 
948  };
949  };
950 
951  /// Appends string presentation of object.
952  ONIXS_EUROTLX_GTP_API void toStr(std::string&, HiddenExecutionIndicator::Enum);
953 
954  /// Returns string presentation of object.
955  inline std::string toStr(HiddenExecutionIndicator::Enum value)
956  {
957  std::string str;
958  toStr(str, value);
959  return str;
960  }
961 
962  /// TradeSummarySide
964  {
965  /// Integral type used as basement for constants.
966  typedef Byte Base;
967 
968  enum Enum
969  {
970  ///
971  NoSide = ' ',
972 
973  ///
974  Buy = 'B',
975 
976  ///
977  Sell = 'S',
978 
979  };
980  };
981 
982  /// Appends string presentation of object.
983  ONIXS_EUROTLX_GTP_API void toStr(std::string&, TradeSummarySide::Enum);
984 
985  /// Returns string presentation of object.
986  inline std::string toStr(TradeSummarySide::Enum value)
987  {
988  std::string str;
989  toStr(str, value);
990  return str;
991  }
992 
993  /// MarketMechanism
995  {
996  /// Integral type used as basement for constants.
997  typedef Byte Base;
998 
999  enum Enum
1000  {
1001  ///
1002  CentralLimitOrderBook = '1',
1003 
1004  ///
1005  QuoteDrivenMarket = '2',
1006 
1007  ///
1008  DarkOrderBook = '3',
1009 
1010  ///
1011  OffBook = '4',
1012 
1013  ///
1014  PeriodicAuction = '5',
1015 
1016  ///
1017  RequestforQuotes = '6',
1018 
1019  ///
1020  AnyOther = '7',
1021 
1022  };
1023  };
1024 
1025  /// Appends string presentation of object.
1026  ONIXS_EUROTLX_GTP_API void toStr(std::string&, MarketMechanism::Enum);
1027 
1028  /// Returns string presentation of object.
1029  inline std::string toStr(MarketMechanism::Enum value)
1030  {
1031  std::string str;
1032  toStr(str, value);
1033  return str;
1034  }
1035 
1036  /// TradingMode
1038  {
1039  /// Integral type used as basement for constants.
1040  typedef Byte Base;
1041 
1042  enum Enum
1043  {
1044  ///
1045  UndefinedAuction = '1',
1046 
1047  ///
1048  ScheduledOpeningAuction = 'O',
1049 
1050  ///
1051  ScheduledClosingAuction = 'K',
1052 
1053  ///
1054  ScheduledIntradayAuction = 'I',
1055 
1056  ///
1057  UnscheduledAuction = 'U',
1058 
1059  ///
1060  ContinuousTrading = '2',
1061 
1062  ///
1063  AtMarketCloseTrading = '3',
1064 
1065  ///
1066  OutOfMainSessionTrading = '4',
1067 
1068  ///
1069  TradeReportingOnExchange = '5',
1070 
1071  ///
1072  TradeReportingOffExchange = '6',
1073 
1074  ///
1075  TradeReportingSystematicInternaliser = '7',
1076 
1077  };
1078  };
1079 
1080  /// Appends string presentation of object.
1081  ONIXS_EUROTLX_GTP_API void toStr(std::string&, TradingMode::Enum);
1082 
1083  /// Returns string presentation of object.
1084  inline std::string toStr(TradingMode::Enum value)
1085  {
1086  std::string str;
1087  toStr(str, value);
1088  return str;
1089  }
1090 
1091  /// TransactionCategory
1093  {
1094  /// Integral type used as basement for constants.
1095  typedef Byte Base;
1096 
1097  enum Enum
1098  {
1099  ///
1100  DarkTrade = 'D',
1101 
1102  ///
1103  TradeThatHasReceivedPriceImprovement = 'R',
1104 
1105  ///
1106  PackageTrade = 'Z',
1107 
1108  ///
1109  ExchangeForPhysicalsTrade = 'Y',
1110 
1111  ///
1112  NoneApply = '-',
1113 
1114  };
1115  };
1116 
1117  /// Appends string presentation of object.
1118  ONIXS_EUROTLX_GTP_API void toStr(std::string&, TransactionCategory::Enum);
1119 
1120  /// Returns string presentation of object.
1121  inline std::string toStr(TransactionCategory::Enum value)
1122  {
1123  std::string str;
1124  toStr(str, value);
1125  return str;
1126  }
1127 
1128  /// NegotiationIndicator
1130  {
1131  /// Integral type used as basement for constants.
1132  typedef Byte Base;
1133 
1134  enum Enum
1135  {
1136  ///
1137  NegotiatedTrade = 'N',
1138 
1139  ///
1140  NegotiatedTradeInLiquidFinancialInstruments = '1',
1141 
1142  ///
1143  NegotiatedTradeInIlliquidFinancialInstruments = '2',
1144 
1145  ///
1146  NegotiatedTradeSubjectToConditionsOtherMarketPrice = '3',
1147 
1148  ///
1149  NotANegotiatedTrade = '-',
1150 
1151  };
1152  };
1153 
1154  /// Appends string presentation of object.
1155  ONIXS_EUROTLX_GTP_API void toStr(std::string&, NegotiationIndicator::Enum);
1156 
1157  /// Returns string presentation of object.
1158  inline std::string toStr(NegotiationIndicator::Enum value)
1159  {
1160  std::string str;
1161  toStr(str, value);
1162  return str;
1163  }
1164 
1165  /// AgencyCrossIndicator
1167  {
1168  /// Integral type used as basement for constants.
1169  typedef Byte Base;
1170 
1171  enum Enum
1172  {
1173  ///
1174  AgencyCrossTrade = 'X',
1175 
1176  ///
1177  NoAgencyCrossTrade = '-',
1178 
1179  };
1180  };
1181 
1182  /// Appends string presentation of object.
1183  ONIXS_EUROTLX_GTP_API void toStr(std::string&, AgencyCrossIndicator::Enum);
1184 
1185  /// Returns string presentation of object.
1186  inline std::string toStr(AgencyCrossIndicator::Enum value)
1187  {
1188  std::string str;
1189  toStr(str, value);
1190  return str;
1191  }
1192 
1193  /// ModificationIndicator
1195  {
1196  /// Integral type used as basement for constants.
1197  typedef Byte Base;
1198 
1199  enum Enum
1200  {
1201  ///
1202  TradeCancellation = 'C',
1203 
1204  ///
1205  TradeAmendment = 'A',
1206 
1207  ///
1208  NewTrade = '-',
1209 
1210  };
1211  };
1212 
1213  /// Appends string presentation of object.
1214  ONIXS_EUROTLX_GTP_API void toStr(std::string&, ModificationIndicator::Enum);
1215 
1216  /// Returns string presentation of object.
1217  inline std::string toStr(ModificationIndicator::Enum value)
1218  {
1219  std::string str;
1220  toStr(str, value);
1221  return str;
1222  }
1223 
1224  /// ReferencePriceIndicator
1226  {
1227  /// Integral type used as basement for constants.
1228  typedef Byte Base;
1229 
1230  enum Enum
1231  {
1232  ///
1233  BenchmarkTrade = 'B',
1234 
1235  ///
1236  ReferencePriceTrade = 'S',
1237 
1238  ///
1239  NotAReferencePriceTrade = '-',
1240 
1241  };
1242  };
1243 
1244  /// Appends string presentation of object.
1245  ONIXS_EUROTLX_GTP_API void toStr(std::string&, ReferencePriceIndicator::Enum);
1246 
1247  /// Returns string presentation of object.
1248  inline std::string toStr(ReferencePriceIndicator::Enum value)
1249  {
1250  std::string str;
1251  toStr(str, value);
1252  return str;
1253  }
1254 
1255  /// SpecialDividendIndicator
1257  {
1258  /// Integral type used as basement for constants.
1259  typedef Byte Base;
1260 
1261  enum Enum
1262  {
1263  ///
1264  SpecialDividendTrade = 'E',
1265 
1266  ///
1267  NoSpecialDividendTrade = '-',
1268 
1269  };
1270  };
1271 
1272  /// Appends string presentation of object.
1273  ONIXS_EUROTLX_GTP_API void toStr(std::string&, SpecialDividendIndicator::Enum);
1274 
1275  /// Returns string presentation of object.
1276  inline std::string toStr(SpecialDividendIndicator::Enum value)
1277  {
1278  std::string str;
1279  toStr(str, value);
1280  return str;
1281  }
1282 
1283  /// OffBookAutomatedIndicator
1285  {
1286  /// Integral type used as basement for constants.
1287  typedef Byte Base;
1288 
1289  enum Enum
1290  {
1291  ///
1292  OffBookNonAutomated = 'M',
1293 
1294  ///
1295  OffBookAutomated = 'Q',
1296 
1297  ///
1298  Unspecified = '-',
1299 
1300  };
1301  };
1302 
1303  /// Appends string presentation of object.
1304  ONIXS_EUROTLX_GTP_API void toStr(std::string&, OffBookAutomatedIndicator::Enum);
1305 
1306  /// Returns string presentation of object.
1307  inline std::string toStr(OffBookAutomatedIndicator::Enum value)
1308  {
1309  std::string str;
1310  toStr(str, value);
1311  return str;
1312  }
1313 
1314  /// PriceFormationIndicator
1316  {
1317  /// Integral type used as basement for constants.
1318  typedef Byte Base;
1319 
1320  enum Enum
1321  {
1322  ///
1323  PlainVanillaTrade = 'P',
1324 
1325  ///
1326  NonPriceFormingTrade = 'T',
1327 
1328  ///
1329  TradeNotContributingToPriceDiscovery = 'J',
1330 
1331  ///
1332  PendingPrice = 'N',
1333 
1334  };
1335  };
1336 
1337  /// Appends string presentation of object.
1338  ONIXS_EUROTLX_GTP_API void toStr(std::string&, PriceFormationIndicator::Enum);
1339 
1340  /// Returns string presentation of object.
1341  inline std::string toStr(PriceFormationIndicator::Enum value)
1342  {
1343  std::string str;
1344  toStr(str, value);
1345  return str;
1346  }
1347 
1348  /// AlgorithmicIndicator
1350  {
1351  /// Integral type used as basement for constants.
1352  typedef Byte Base;
1353 
1354  enum Enum
1355  {
1356  ///
1357  AlgorithmicTrade = 'H',
1358 
1359  ///
1360  NotAlgorithmicTrade = '-',
1361 
1362  };
1363  };
1364 
1365  /// Appends string presentation of object.
1366  ONIXS_EUROTLX_GTP_API void toStr(std::string&, AlgorithmicIndicator::Enum);
1367 
1368  /// Returns string presentation of object.
1369  inline std::string toStr(AlgorithmicIndicator::Enum value)
1370  {
1371  std::string str;
1372  toStr(str, value);
1373  return str;
1374  }
1375 
1376  /// PostTradeDeferralReason
1378  {
1379  /// Integral type used as basement for constants.
1380  typedef Byte Base;
1381 
1382  enum Enum
1383  {
1384  ///
1385  DeferralForLargeInScale = '2',
1386 
1387  ///
1388  DeferralForIlliquidInstrument = '3',
1389 
1390  ///
1391  DeferralForSizeSpecific = '4',
1392 
1393  ///
1394  DeferralsOfIlqdAndSize = '5',
1395 
1396  ///
1397  DeferralsOfIlqdAndLrgs = '6',
1398 
1399  ///
1400  ImmediatePublication = '-',
1401 
1402  };
1403  };
1404 
1405  /// Appends string presentation of object.
1406  ONIXS_EUROTLX_GTP_API void toStr(std::string&, PostTradeDeferralReason::Enum);
1407 
1408  /// Returns string presentation of object.
1409  inline std::string toStr(PostTradeDeferralReason::Enum value)
1410  {
1411  std::string str;
1412  toStr(str, value);
1413  return str;
1414  }
1415 
1416  /// DeferralEnrichmentType
1418  {
1419  /// Integral type used as basement for constants.
1420  typedef Byte Base;
1421 
1422  enum Enum
1423  {
1424  ///
1425  LMTF = '1',
1426 
1427  ///
1428  DATF = '2',
1429 
1430  ///
1431  VOLO = '3',
1432 
1433  ///
1434  FWAF = '4',
1435 
1436  ///
1437  IDAF = '5',
1438 
1439  ///
1440  VOLW = '6',
1441 
1442  ///
1443  FULF = '7',
1444 
1445  ///
1446  FULA = '8',
1447 
1448  ///
1449  FULV = '9',
1450 
1451  ///
1452  FULJ = 'V',
1453 
1454  ///
1455  COAF = 'W',
1456 
1457  ///
1458  NotApplicable = '-',
1459 
1460  };
1461  };
1462 
1463  /// Appends string presentation of object.
1464  ONIXS_EUROTLX_GTP_API void toStr(std::string&, DeferralEnrichmentType::Enum);
1465 
1466  /// Returns string presentation of object.
1467  inline std::string toStr(DeferralEnrichmentType::Enum value)
1468  {
1469  std::string str;
1470  toStr(str, value);
1471  return str;
1472  }
1473 
1474  /// DuplicativeIndicator
1476  {
1477  /// Integral type used as basement for constants.
1478  typedef Byte Base;
1479 
1480  enum Enum
1481  {
1482  ///
1483  DuplicativeTradeReport = '1',
1484 
1485  ///
1486  UniqueTradeReport = '-',
1487 
1488  };
1489  };
1490 
1491  /// Appends string presentation of object.
1492  ONIXS_EUROTLX_GTP_API void toStr(std::string&, DuplicativeIndicator::Enum);
1493 
1494  /// Returns string presentation of object.
1495  inline std::string toStr(DuplicativeIndicator::Enum value)
1496  {
1497  std::string str;
1498  toStr(str, value);
1499  return str;
1500  }
1501 
1502 }
1503 }
1504 }
1505 }
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:189
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:966
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:997
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:220
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:356
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:825
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:69
UInt16 Base
Integral type used as basement for constants.
Definition: Enumerations.h:568
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:424
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:687
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:485
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:730
UInt16 Base
Integral type used as basement for constants.
Definition: Enumerations.h:767
Byte Base
Integral type used as basement for constants.
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:109
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:935
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:35
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:384
UInt8 Base
Integral type used as basement for constants.
Definition: Enumerations.h:137
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:647
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:251
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:310
UInt8 Byte
Alias for Byte.
Definition: Memory.h:37
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:516
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:282
ONIXS_EUROTLX_GTP_API void toStr(std::string &, EventCode::Enum)
Appends string presentation of object.
Byte Base
Integral type used as basement for constants.
Definition: Enumerations.h:901