OnixS C++ Euronext Optiq MDG Handler  1.3.3
API documentation
Fields.h
Go to the documentation of this file.
1 // Copyright Onix Solutions Limited [OnixS]. All rights reserved.
2 //
3 // This software owned by Onix Solutions Limited [OnixS] and is
4 // protected by copyright law and international copyright treaties.
5 //
6 // Access to and use of the software is governed by the terms of the applicable
7 // OnixS Software Services Agreement (the Agreement) and Customer end user license
8 // agreements granting a non-assignable, non-transferable and non-exclusive license
9 // to use the software for it's own data processing purposes under the terms defined
10 // in the Agreement.
11 //
12 // Except as otherwise granted within the terms of the Agreement, copying or
13 // reproduction of any part of this source code or associated reference material
14 // to any other location for further reproduction or redistribution, and any
15 // amendments to this copyright notice, are expressly prohibited.
16 //
17 // Any reproduction or redistribution for sale or hiring of the Software not in
18 // accordance with the terms of the Agreement is a violation of copyright law.
19 //
20 
21 #pragma once
22 
25 
27 
28 /// Type alias for the `Unsigned_char`.
30 
31 
32 /// Type alias for the `Int8_t`.
33 typedef Int8 Int8;
34 
35 
36 /// Type alias for the `Uint16_t`.
37 typedef UInt16 Uint16;
38 
39 
40 /// Type alias for the `Uint32_t`.
41 typedef UInt32 Uint32;
42 
43 
44 /// Type alias for the `Uint64_t`.
45 typedef UInt64 Uint64;
46 
47 
48 /// Type alias for the `Int32_t`.
49 typedef Int32 Int32;
50 
51 
52 /// Type alias for the `Int64_t`.
53 typedef Int64 Int64;
54 
55 
56 /// Type alias for the `Time_t`.
57 typedef UInt64 Time;
58 
59 
60 /// Type alias for the `Char1`.
61 typedef Char Char1;
62 
63 
64 /// Type alias for the `Char2`.
65 typedef Char Char2[2];
66 
67 
68 /// Type alias for the `Char3`.
69 typedef Char Char3[3];
70 
71 
72 /// Type alias for the `Char4`.
73 typedef Char Char4[4];
74 
75 
76 /// Type alias for the `Char5`.
77 typedef Char Char5[5];
78 
79 
80 /// Type alias for the `Char6`.
81 typedef Char Char6[6];
82 
83 
84 /// Type alias for the `Char7`.
85 typedef Char Char7[7];
86 
87 
88 /// Type alias for the `Char8`.
89 typedef Char Char8[8];
90 
91 
92 /// Type alias for the `Char10`.
93 typedef Char Char10[10];
94 
95 
96 /// Type alias for the `Char11`.
97 typedef Char Char11[11];
98 
99 
100 /// Type alias for the `Char12`.
101 typedef Char Char12[12];
102 
103 
104 /// Type alias for the `Char13`.
105 typedef Char Char13[13];
106 
107 
108 /// Type alias for the `Char15`.
109 typedef Char Char15[15];
110 
111 
112 /// Type alias for the `Char16`.
113 typedef Char Char16[16];
114 
115 
116 /// Type alias for the `Char18`.
117 typedef Char Char18[18];
118 
119 
120 /// Type alias for the `Char20`.
121 typedef Char Char20[20];
122 
123 
124 /// Type alias for the `Char24`.
125 typedef Char Char24[24];
126 
127 
128 /// Type alias for the `Char25`.
129 typedef Char Char25[25];
130 
131 
132 /// Type alias for the `Char27`.
133 typedef Char Char27[27];
134 
135 
136 /// Type alias for the `Char30`.
137 typedef Char Char30[30];
138 
139 
140 /// Type alias for the `Char32`.
141 typedef Char Char32[32];
142 
143 
144 /// Type alias for the `Char50`.
145 typedef Char Char50[50];
146 
147 
148 /// Type alias for the `Char52`.
149 typedef Char Char52[52];
150 
151 
152 /// Type alias for the `Char60`.
153 typedef Char Char60[60];
154 
155 
156 /// Type alias for the `Char100`.
157 typedef Char Char100[100];
158 
159 
160 /// Type alias for the `Char102`.
161 typedef Char Char102[102];
162 
163 
164 /// Type alias for the `Char250`.
165 typedef Char Char250[250];
166 
167 
168 /// `PricingAlgorithm_enum` type.
170 {
171  typedef UInt8 Base;
172 
173  enum Enum
174  {
175  /// Standard
176  Standard = 0,
177 
178  /// TotalReturnFuture
179  TotalReturnFuture = 1,
180 
181  /// MarketOnClose
182  MarketOnClose = 2,
183 
184  /// StandardWithNegativePrices
185  StandardWithNegativePrices = 3
186  };
187 
188  /// \return a human-readable presentation.
190  static
191  std::string
192  toString(
193  Enum);
194 };
195 
196 /// `AccountType_enum` type.
198 {
199  typedef UInt8 Base;
200 
201  enum Enum
202  {
203  /// Client
204  Client = 1,
205 
206  /// House
207  House = 2,
208 
209  /// RO
210  RO = 4,
211 
212  /// AssignedBroker
213  AssignedBroker = 5,
214 
215  /// LiquidityProvider
216  LiquidityProvider = 6,
217 
218  /// RelatedParty
219  RelatedParty = 7,
220 
221  /// StructuredProductMarketMaker
222  StructuredProductMarketMaker = 8,
223 
224  /// OmegaClient
225  OmegaClient = 14,
226 
227  /// CeresClient
228  CeresClient = 15
229  };
230 
231  /// \return a human-readable presentation.
233  static
234  std::string
235  toString(
236  Enum);
237 };
238 
239 /// `Session_enum` type.
241 {
242  typedef UInt8 Base;
243 
244  enum Enum
245  {
246  /// Session0
247  Session0 = 0,
248 
249  /// Session1
250  Session1 = 1,
251 
252  /// Session2
253  Session2 = 2,
254 
255  /// Session3
256  Session3 = 3,
257 
258  /// Session4
259  Session4 = 4,
260 
261  /// Session5
262  Session5 = 5,
263 
264  /// Session6
265  Session6 = 6,
266 
267  /// Session7
268  Session7 = 7,
269 
270  /// Session8
271  Session8 = 8,
272 
273  /// Session9
274  Session9 = 9
275  };
276 
277  /// \return a human-readable presentation.
279  static
280  std::string
281  toString(
282  Enum);
283 };
284 
285 /// `TechnicalNotificationType_enum` type.
287 {
288  typedef UInt8 Base;
289 
290  enum Enum
291  {
292  /// InstrumentBookRetransmissionEnd
293  InstrumentBookRetransmissionEnd = 1,
294 
295  /// TradeRetransmissionStart
296  TradeRetransmissionStart = 10,
297 
298  /// TradeRetransmissionEnd
299  TradeRetransmissionEnd = 11
300  };
301 
302  /// \return a human-readable presentation.
304  static
305  std::string
306  toString(
307  Enum);
308 };
309 
310 /// `ScheduledEvent_enum` type.
312 {
313  typedef UInt8 Base;
314 
315  enum Enum
316  {
317  /// CancelPreviouslyScheduledEvent
318  CancelPreviouslyScheduledEvent = 0,
319 
320  /// Reopening
321  Reopening = 1,
322 
323  /// ResumptionOfTrading
324  ResumptionOfTrading = 3,
325 
326  /// Closed
327  Closed = 4,
328 
329  /// Expiry
330  Expiry = 5,
331 
332  /// WholesaleLargeInScaleLiSTradesOpenExtension
333  WholesaleLargeInScaleLiSTradesOpenExtension = 6,
334 
335  /// WholesaleBasisTradesOpenExtension
336  WholesaleBasisTradesOpenExtension = 7,
337 
338  /// WholesaleAgainstActualsTradesOpenExtension
339  WholesaleAgainstActualsTradesOpenExtension = 8,
340 
341  /// WholesaleLargeInScaleLiSPackageTradesOpenExtension
342  WholesaleLargeInScaleLiSPackageTradesOpenExtension = 9,
343 
344  /// WholesaleExchangeForSwapsTradesOpenExtension
345  WholesaleExchangeForSwapsTradesOpenExtension = 10,
346 
347  /// WholesaleTradesOpenExtension
348  WholesaleTradesOpenExtension = 11,
349 
350  /// Suspension
351  Suspension = 12,
352 
353  /// CollarsNormal
354  CollarsNormal = 13,
355 
356  /// CollarsWide
357  CollarsWide = 14,
358 
359  /// PreExpiry
360  PreExpiry = 15,
361 
362  /// ClosingPrice
363  ClosingPrice = 16
364  };
365 
366  /// \return a human-readable presentation.
368  static
369  std::string
370  toString(
371  Enum);
372 };
373 
374 /// `StatusReason_enum` type.
376 {
377  typedef UInt8 Base;
378 
379  enum Enum
380  {
381  /// Scheduled
382  Scheduled = 0,
383 
384  /// CollarsBreach
385  CollarsBreach = 4,
386 
387  /// AutomaticReopening
388  AutomaticReopening = 7,
389 
390  /// NoLiquidityProvider
391  NoLiquidityProvider = 8,
392 
393  /// KnockInByIssuer
394  KnockInByIssuer = 11,
395 
396  /// KnockOutByExchange
397  KnockOutByExchange = 12,
398 
399  /// KnockOutByIssuer
400  KnockOutByIssuer = 13,
401 
402  /// ActionByMarketOperations
403  ActionByMarketOperations = 15,
404 
405  /// WaitingForTradableState
406  WaitingForTradableState = 16,
407 
408  /// NewListing
409  NewListing = 20,
410 
411  /// DueToUnderlying
412  DueToUnderlying = 21,
413 
414  /// OutsideOfLPQuotes
415  OutsideOfLPQuotes = 22,
416 
417  /// Technical
418  Technical = 23,
419 
420  /// DueToLeg
421  DueToLeg = 24,
422 
423  /// DueToMainMarket
424  DueToMainMarket = 25
425  };
426 
427  /// \return a human-readable presentation.
429  static
430  std::string
431  toString(
432  Enum);
433 };
434 
435 /// `ImbalanceQuantitySide_enum` type.
437 {
438  typedef UInt8 Base;
439 
440  enum Enum
441  {
442  /// NoImbalance
443  NoImbalance = 0,
444 
445  /// Buy
446  Buy = 1,
447 
448  /// Sell
449  Sell = 2
450  };
451 
452  /// \return a human-readable presentation.
454  static
455  std::string
456  toString(
457  Enum);
458 };
459 
460 /// `InstrumentCategory_enum` type.
462 {
463  typedef UInt8 Base;
464 
465  enum Enum
466  {
467  /// Equities
468  Equities = 1,
469 
470  /// FixedIncome
471  FixedIncome = 2,
472 
473  /// WarrantsAndCertificates
474  WarrantsAndCertificates = 3,
475 
476  /// Trackers
477  Trackers = 6,
478 
479  /// Futures
480  Futures = 7,
481 
482  /// Options
483  Options = 10,
484 
485  /// Indices
486  Indices = 11,
487 
488  /// EuronextFundsServices
489  EuronextFundsServices = 12,
490 
491  /// INAVIndicativeNetAssetValue
492  INAVIndicativeNetAssetValue = 14,
493 
494  /// Fund
495  Fund = 15,
496 
497  /// Forex
498  Forex = 16,
499 
500  /// Miscellaneous
501  Miscellaneous = 254
502  };
503 
504  /// \return a human-readable presentation.
506  static
507  std::string
508  toString(
509  Enum);
510 };
511 
512 /// `InstrumentUnitExpression_enum` type.
514 {
515  typedef UInt8 Base;
516 
517  enum Enum
518  {
519  /// Units
520  Units = 1,
521 
522  /// PercentageOfNominalExcludingAccruedInterestClean
523  PercentageOfNominalExcludingAccruedInterestClean = 2,
524 
525  /// BasisPoints
526  BasisPoints = 3,
527 
528  /// PercentageMixed
529  PercentageMixed = 4,
530 
531  /// PercentageOfNominalIncludingAccruedInterestDirty
532  PercentageOfNominalIncludingAccruedInterestDirty = 5,
533 
534  /// PercentageOfParValue
535  PercentageOfParValue = 6,
536 
537  /// Yield
538  Yield = 7,
539 
540  /// Kilograms
541  Kilograms = 8,
542 
543  /// Ounces
544  Ounces = 9
545  };
546 
547  /// \return a human-readable presentation.
549  static
550  std::string
551  toString(
552  Enum);
553 };
554 
555 /// `RepoIndicator_enum` type.
557 {
558  typedef UInt8 Base;
559 
560  enum Enum
561  {
562  /// InstrNeitherEligibleForSRDOrLoanAndLendingMkt
563  InstrNeitherEligibleForSRDOrLoanAndLendingMkt = 0,
564 
565  /// InstrEligibleForSRDAndForLoanAndLendingMarket
566  InstrEligibleForSRDAndForLoanAndLendingMarket = 1,
567 
568  /// InstrEligibleForTheSRDLongOnly
569  InstrEligibleForTheSRDLongOnly = 2,
570 
571  /// InstrEligibleForLoanAndLendingMktAndForSRDLongOnly
572  InstrEligibleForLoanAndLendingMktAndForSRDLongOnly = 3,
573 
574  /// EasytoborrowInstrEligibleForSRDAndForLoanAndLendingMkt
575  EasytoborrowInstrEligibleForSRDAndForLoanAndLendingMkt = 4,
576 
577  /// InstrEligibleForTheLoanAndLendingMarket
578  InstrEligibleForTheLoanAndLendingMarket = 5,
579 
580  /// NonSignificant
581  NonSignificant = 8
582  };
583 
584  /// \return a human-readable presentation.
586  static
587  std::string
588  toString(
589  Enum);
590 };
591 
592 /// `StrikeCurrencyIndicator_enum` type.
594 {
595  typedef UInt8 Base;
596 
597  enum Enum
598  {
599  /// ChangeRateNotAppliedToTheStrikePrice
600  ChangeRateNotAppliedToTheStrikePrice = 0,
601 
602  /// ChangeRateAppliedToTheStrikePrice
603  ChangeRateAppliedToTheStrikePrice = 1
604  };
605 
606  /// \return a human-readable presentation.
608  static
609  std::string
610  toString(
611  Enum);
612 };
613 
614 /// `TradingCurrencyIndicator_enum` type.
616 {
617  typedef UInt8 Base;
618 
619  enum Enum
620  {
621  /// ChangeRateNotAppliedToTheTradedPrice
622  ChangeRateNotAppliedToTheTradedPrice = 0,
623 
624  /// ChangeRateAppliedToTheTradedPrice
625  ChangeRateAppliedToTheTradedPrice = 1
626  };
627 
628  /// \return a human-readable presentation.
630  static
631  std::string
632  toString(
633  Enum);
634 };
635 
636 /// `ContractType_enum` type.
638 {
639  typedef Char Base;
640 
641  enum Enum
642  {
643  /// Future
644  Future = 'F',
645 
646  /// Option
647  Option = 'O',
648 
649  /// Underlying
650  Underlying = 'U'
651  };
652 
653  /// \return a human-readable presentation.
655  static
656  std::string
657  toString(
658  Enum);
659 };
660 
661 /// `ExpiryCycleType_enum` type.
663 {
664  typedef UInt8 Base;
665 
666  enum Enum
667  {
668  /// Daily
669  Daily = 1,
670 
671  /// Weekly
672  Weekly = 2,
673 
674  /// Monthly
675  Monthly = 3,
676 
677  /// Quarterly
678  Quarterly = 4,
679 
680  /// HalfYearly
681  HalfYearly = 5,
682 
683  /// Yearly
684  Yearly = 6
685  };
686 
687  /// \return a human-readable presentation.
689  static
690  std::string
691  toString(
692  Enum);
693 };
694 
695 /// `MessagePriceNotation_enum` type.
697 {
698  typedef UInt8 Base;
699 
700  enum Enum
701  {
702  /// Price
703  Price = 1,
704 
705  /// SpreadInBasisPoints
706  SpreadInBasisPoints = 2,
707 
708  /// Spread
709  Spread = 3
710  };
711 
712  /// \return a human-readable presentation.
714  static
715  std::string
716  toString(
717  Enum);
718 };
719 
720 /// `UnderlyingType_enum` type.
722 {
723  typedef Char Base;
724 
725  enum Enum
726  {
727  /// BasketWithCommodity
728  BasketWithCommodity = 'A',
729 
730  /// Basket
731  Basket = 'B',
732 
733  /// Commodity
734  Commodity = 'C',
735 
736  /// DepositaryReceipt
737  DepositaryReceipt = 'D',
738 
739  /// Future
740  Future = 'F',
741 
742  /// CurrencyLeveragedIndex
743  CurrencyLeveragedIndex = 'G',
744 
745  /// Other
746  Other = 'H',
747 
748  /// Index
749  Index = 'I',
750 
751  /// Bonds
752  Bonds = 'J',
753 
754  /// StockDividend
755  StockDividend = 'K',
756 
757  /// LeveragedIndex
758  LeveragedIndex = 'L',
759 
760  /// InterestRate
761  InterestRate = 'N',
762 
763  /// OtherDerivative
764  OtherDerivative = 'O',
765 
766  /// CommodityIndex
767  CommodityIndex = 'P',
768 
769  /// CommodityLeveragedIndex
770  CommodityLeveragedIndex = 'Q',
771 
772  /// Right
773  Right = 'R',
774 
775  /// Stock
776  Stock = 'S',
777 
778  /// Credit
779  Credit = 'T',
780 
781  /// Fund
782  Fund = 'U',
783 
784  /// Currency
785  Currency = 'V',
786 
787  /// StockWarrant
788  StockWarrant = 'W',
789 
790  /// ExchangeRate
791  ExchangeRate = 'X',
792 
793  /// SecurityLeveragedIndex
794  SecurityLeveragedIndex = 'Z'
795  };
796 
797  /// \return a human-readable presentation.
799  static
800  std::string
801  toString(
802  Enum);
803 };
804 
805 /// `StrategyCode_enum` type.
807 {
808  typedef Char Base;
809 
810  enum Enum
811  {
812  /// JellyRoll
813  JellyRoll = 'A',
814 
815  /// Butterfly
816  Butterfly = 'B',
817 
818  /// CallOrPutCabinet
819  CallOrPutCabinet = 'C',
820 
821  /// Spread
822  Spread = 'D',
823 
824  /// CalendarSpread
825  CalendarSpread = 'E',
826 
827  /// DiagonalCalendarSpread
828  DiagonalCalendarSpread = 'F',
829 
830  /// Guts
831  Guts = 'G',
832 
833  /// TwoByOneRatioSpread
834  TwoByOneRatioSpread = 'H',
835 
836  /// IronButterfly
837  IronButterfly = 'I',
838 
839  /// Combo
840  Combo = 'J',
841 
842  /// Strangle
843  Strangle = 'K',
844 
845  /// Ladder
846  Ladder = 'L',
847 
848  /// Strip
849  Strip = 'M',
850 
851  /// StraddleCalendarSpread
852  StraddleCalendarSpread = 'N',
853 
854  /// Pack
855  Pack = 'O',
856 
857  /// DiagonalStraddleCalendarSpread
858  DiagonalStraddleCalendarSpread = 'P',
859 
860  /// SimpleInterCommoditySpread
861  SimpleInterCommoditySpread = 'Q',
862 
863  /// ConversionReversal
864  ConversionReversal = 'R',
865 
866  /// Straddle
867  Straddle = 'S',
868 
869  /// VolatilityTrade
870  VolatilityTrade = 'V',
871 
872  /// Condor
873  Condor = 'W',
874 
875  /// Box
876  Box = 'X',
877 
878  /// Bundle
879  Bundle = 'Y',
880 
881  /// ReducedTickSpread
882  ReducedTickSpread = 'Z',
883 
884  /// LadderVersusUnderlying
885  LadderVersusUnderlying = 'a',
886 
887  /// ButterflyVersusUnderlying
888  ButterflyVersusUnderlying = 'b',
889 
890  /// CallSpreadVersusPutVersusUnderlying
891  CallSpreadVersusPutVersusUnderlying = 'c',
892 
893  /// CallOrPutSpreadVersusUnderlying
894  CallOrPutSpreadVersusUnderlying = 'd',
895 
896  /// CallOrPutCalendarSpreadVersusUnderlying
897  CallOrPutCalendarSpreadVersusUnderlying = 'e',
898 
899  /// CallPutDiagonalCalendarSpreadVersusUnderlying
900  CallPutDiagonalCalendarSpreadVersusUnderlying = 'f',
901 
902  /// GutsVersusUnderlying
903  GutsVersusUnderlying = 'g',
904 
905  /// TwoByOneCallOrPutRatioSpreadVersusUnderlying
906  TwoByOneCallOrPutRatioSpreadVersusUnderlying = 'h',
907 
908  /// IronButterflyVersusUnderlying
909  IronButterflyVersusUnderlying = 'i',
910 
911  /// ComboVersusUnderlying
912  ComboVersusUnderlying = 'j',
913 
914  /// StrangleVersusUnderlying
915  StrangleVersusUnderlying = 'k',
916 
917  /// ExchangeForPhysical
918  ExchangeForPhysical = 'm',
919 
920  /// StraddleCalendarSpreadVersusUnderlying
921  StraddleCalendarSpreadVersusUnderlying = 'n',
922 
923  /// PutSpreadVersusCallVersusUnderlying
924  PutSpreadVersusCallVersusUnderlying = 'p',
925 
926  /// DiagonalStraddleCalendarSpreadVersusUnderlying
927  DiagonalStraddleCalendarSpreadVersusUnderlying = 'q',
928 
929  /// Synthetic
930  Synthetic = 'r',
931 
932  /// StraddleVersusUnderlying
933  StraddleVersusUnderlying = 's',
934 
935  /// CondorVersusUnderlying
936  CondorVersusUnderlying = 't',
937 
938  /// BuyWrite
939  BuyWrite = 'u',
940 
941  /// IronCondorVersusUnderlying
942  IronCondorVersusUnderlying = 'v',
943 
944  /// IronCondor
945  IronCondor = 'w',
946 
947  /// CallSpreadVersusSellAPut
948  CallSpreadVersusSellAPut = 'x',
949 
950  /// PutSpreadVersusSellACall
951  PutSpreadVersusSellACall = 'y',
952 
953  /// PutStraddleVersusSellACallOrAPut
954  PutStraddleVersusSellACallOrAPut = 'z',
955 
956  /// ICSOneSidedCombinationSameExpiry
957  ICSOneSidedCombinationSameExpiry = 'T',
958 
959  /// ICSTwoSidedCombinationSameExpiry
960  ICSTwoSidedCombinationSameExpiry = 'U'
961  };
962 
963  /// \return a human-readable presentation.
965  static
966  std::string
967  toString(
968  Enum);
969 };
970 
971 /// `MarketDataActionType_enum` type.
973 {
974  typedef UInt8 Base;
975 
976  enum Enum
977  {
978  /// NewOrder
979  NewOrder = 1,
980 
981  /// DeletionOfIdentifiedOrder
982  DeletionOfIdentifiedOrder = 2,
983 
984  /// DeletionOfAllOrdersBySide
985  DeletionOfAllOrdersBySide = 3,
986 
987  /// ModificationOfExistingOrderWithoutLossOfPriority
988  ModificationOfExistingOrderWithoutLossOfPriority = 4,
989 
990  /// RetransmissionOfAllOrders
991  RetransmissionOfAllOrders = 5,
992 
993  /// ModificationOfExistingOrderWithLossOfPriority
994  ModificationOfExistingOrderWithLossOfPriority = 6,
995 
996  /// RFQAnswerCreation
997  RFQAnswerCreation = 7,
998 
999  /// RFQAnswerDeletion
1000  RFQAnswerDeletion = 8
1001  };
1002 
1003  /// \return a human-readable presentation.
1005  static
1006  std::string
1007  toString(
1008  Enum);
1009 };
1010 
1011 /// `MarketDataPriceType_enum` type.
1013 {
1014  typedef UInt8 Base;
1015 
1016  enum Enum
1017  {
1018  /// OfficialDaily
1019  OfficialDaily = 2,
1020 
1021  /// OfficialMarketClose
1022  OfficialMarketClose = 4,
1023 
1024  /// OfficialExpiry
1025  OfficialExpiry = 6,
1026 
1027  /// ProvisionalIntraday
1028  ProvisionalIntraday = 7,
1029 
1030  /// OfficialIntraday
1031  OfficialIntraday = 8,
1032 
1033  /// OfficialYDSP
1034  OfficialYDSP = 9,
1035 
1036  /// NAVForTheInstrumentsEligibleToTheNAVTradingFacility
1037  NAVForTheInstrumentsEligibleToTheNAVTradingFacility = 10,
1038 
1039  /// AdjustedClosingPrice
1040  AdjustedClosingPrice = 12,
1041 
1042  /// SubscriptionPrice
1043  SubscriptionPrice = 13,
1044 
1045  /// IndicativeMatchingPrice
1046  IndicativeMatchingPrice = 14,
1047 
1048  /// MinPriceOutOfSessionTrades
1049  MinPriceOutOfSessionTrades = 19,
1050 
1051  /// MaxPriceOutOfSessionTrades
1052  MaxPriceOutOfSessionTrades = 20,
1053 
1054  /// MinPriceOutOfSessionBlockTrades
1055  MinPriceOutOfSessionBlockTrades = 21,
1056 
1057  /// MaxPriceOutOfSessionBlockTrades
1058  MaxPriceOutOfSessionBlockTrades = 22,
1059 
1060  /// ValuationPrice
1061  ValuationPrice = 23,
1062 
1063  /// FundSubscription
1064  FundSubscription = 24,
1065 
1066  /// FundRedemption
1067  FundRedemption = 25,
1068 
1069  /// UncrossingPrice
1070  UncrossingPrice = 26,
1071 
1072  /// LastTradedPrice
1073  LastTradedPrice = 27,
1074 
1075  /// AIP
1076  AIP = 28,
1077 
1078  /// NetAssetValue
1079  NetAssetValue = 30,
1080 
1081  /// ExternalReferencePrice
1082  ExternalReferencePrice = 31,
1083 
1084  /// ClosingPrice
1085  ClosingPrice = 33
1086  };
1087 
1088  /// \return a human-readable presentation.
1090  static
1091  std::string
1092  toString(
1093  Enum);
1094 };
1095 
1096 /// `UnderlyingSubtype_enum` type.
1098 {
1099  typedef UInt8 Base;
1100 
1101  enum Enum
1102  {
1103  /// Basket
1104  Basket = 0,
1105 
1106  /// Dividend
1107  Dividend = 1,
1108 
1109  /// ETF
1110  ETF = 2,
1111 
1112  /// Share
1113  Share = 3,
1114 
1115  /// DividendIndex
1116  DividendIndex = 4,
1117 
1118  /// EquityIndex
1119  EquityIndex = 5,
1120 
1121  /// TRFIndex
1122  TRFIndex = 6,
1123 
1124  /// VolatilityIndex
1125  VolatilityIndex = 7,
1126 
1127  /// FutureOnCommodities
1128  FutureOnCommodities = 8,
1129 
1130  /// FXCrossRates
1131  FXCrossRates = 9,
1132 
1133  /// FXEmergingMarkets
1134  FXEmergingMarkets = 10,
1135 
1136  /// FXMajors
1137  FXMajors = 11,
1138 
1139  /// Agricultural
1140  Agricultural = 12,
1141 
1142  /// Environmental
1143  Environmental = 13,
1144 
1145  /// Freight
1146  Freight = 14,
1147 
1148  /// Fertilizer
1149  Fertilizer = 15,
1150 
1151  /// IndustrialProducts
1152  IndustrialProducts = 16,
1153 
1154  /// Inflation
1155  Inflation = 17,
1156 
1157  /// MultiCommodityExotic
1158  MultiCommodityExotic = 18,
1159 
1160  /// Metals
1161  Metals = 19,
1162 
1163  /// Energy
1164  Energy = 20,
1165 
1166  /// OfficialEconomicStatistics
1167  OfficialEconomicStatistics = 21,
1168 
1169  /// OtherC10
1170  OtherC10 = 22,
1171 
1172  /// Other
1173  Other = 23,
1174 
1175  /// Paper
1176  Paper = 24,
1177 
1178  /// Polypropylene
1179  Polypropylene = 25,
1180 
1181  /// BondsBasket
1182  BondsBasket = 26
1183  };
1184 
1185  /// \return a human-readable presentation.
1187  static
1188  std::string
1189  toString(
1190  Enum);
1191 };
1192 
1193 /// `QuoteUpdateType_enum` type.
1195 {
1196  typedef UInt8 Base;
1197 
1198  enum Enum
1199  {
1200  /// BestBid
1201  BestBid = 1,
1202 
1203  /// BestOffer
1204  BestOffer = 2,
1205 
1206  /// CancelBid
1207  CancelBid = 5,
1208 
1209  /// CancelOffer
1210  CancelOffer = 6
1211  };
1212 
1213  /// \return a human-readable presentation.
1215  static
1216  std::string
1217  toString(
1218  Enum);
1219 };
1220 
1221 /// `MarketDataUpdateType_enum` type.
1223 {
1224  typedef UInt8 Base;
1225 
1226  enum Enum
1227  {
1228  /// BestBid
1229  BestBid = 1,
1230 
1231  /// BestOffer
1232  BestOffer = 2,
1233 
1234  /// NewBid
1235  NewBid = 3,
1236 
1237  /// NewOffer
1238  NewOffer = 4,
1239 
1240  /// UpdatedBid
1241  UpdatedBid = 5,
1242 
1243  /// UpdatedOffer
1244  UpdatedOffer = 6,
1245 
1246  /// TotalTradedVolume
1247  TotalTradedVolume = 7,
1248 
1249  /// ImpliedBid
1250  ImpliedBid = 8,
1251 
1252  /// ImpliedOffer
1253  ImpliedOffer = 9,
1254 
1255  /// RequestForQuote
1256  RequestForQuote = 10,
1257 
1258  /// RequestForQuoteBid
1259  RequestForQuoteBid = 11,
1260 
1261  /// RequestForSize
1262  RequestForSize = 12,
1263 
1264  /// RequestForQuoteOffer
1265  RequestForQuoteOffer = 13,
1266 
1267  /// HighDynamicCollar
1268  HighDynamicCollar = 14,
1269 
1270  /// LowDynamicCollar
1271  LowDynamicCollar = 15,
1272 
1273  /// NewBidRLP
1274  NewBidRLP = 16,
1275 
1276  /// NewOfferRLP
1277  NewOfferRLP = 17,
1278 
1279  /// UpdatedBidRLP
1280  UpdatedBidRLP = 18,
1281 
1282  /// UpdatedOfferRLP
1283  UpdatedOfferRLP = 19,
1284 
1285  /// ConventionalTrade
1286  ConventionalTrade = 24,
1287 
1288  /// RequestForCrossRFCQueued
1289  RequestForCrossRFCQueued = 25,
1290 
1291  /// RequestForCrossRFC
1292  RequestForCrossRFC = 26,
1293 
1294  /// LargeInScaleLiSTrade
1295  LargeInScaleLiSTrade = 27,
1296 
1297  /// BasisTrade
1298  BasisTrade = 28,
1299 
1300  /// LargeInScaleLiSPackageTrade
1301  LargeInScaleLiSPackageTrade = 29,
1302 
1303  /// GuaranteedCrossTrade
1304  GuaranteedCrossTrade = 30,
1305 
1306  /// AgainstActualTrade
1307  AgainstActualTrade = 31,
1308 
1309  /// AssetAllocationTrade
1310  AssetAllocationTrade = 32,
1311 
1312  /// ExchangeForSwapTrade
1313  ExchangeForSwapTrade = 34,
1314 
1315  /// DarkTrade
1316  DarkTrade = 35,
1317 
1318  /// ExchangeForPhysicalTradeCashLeg
1319  ExchangeForPhysicalTradeCashLeg = 36,
1320 
1321  /// StrategyLegConventionalTrade
1322  StrategyLegConventionalTrade = 37,
1323 
1324  /// StrategyLegLargeInScaleLiSTrade
1325  StrategyLegLargeInScaleLiSTrade = 38,
1326 
1327  /// StrategyLegBasisTrade
1328  StrategyLegBasisTrade = 39,
1329 
1330  /// StrategyLegGuaranteedCrossTrade
1331  StrategyLegGuaranteedCrossTrade = 40,
1332 
1333  /// StrategyLegAgainstActualTrade
1334  StrategyLegAgainstActualTrade = 41,
1335 
1336  /// StrategyLegAssetAllocationTrade
1337  StrategyLegAssetAllocationTrade = 42,
1338 
1339  /// StrategyLegExchangeForSwapTrade
1340  StrategyLegExchangeForSwapTrade = 44,
1341 
1342  /// StrategyLegExchangeForPhysicalTrade
1343  StrategyLegExchangeForPhysicalTrade = 45,
1344 
1345  /// BoBTrade
1346  BoBTrade = 46,
1347 
1348  /// AtomXTrade
1349  AtomXTrade = 48,
1350 
1351  /// TradeCancellation
1352  TradeCancellation = 50,
1353 
1354  /// OutOfMarketTrade
1355  OutOfMarketTrade = 51,
1356 
1357  /// DeltaNeutralTradeUnderlyingCashLeg
1358  DeltaNeutralTradeUnderlyingCashLeg = 52,
1359 
1360  /// DeltaNeutralTradeUnderlyingFutureLeg
1361  DeltaNeutralTradeUnderlyingFutureLeg = 53,
1362 
1363  /// EuronextFundServiceTrade
1364  EuronextFundServiceTrade = 54,
1365 
1366  /// SecondaryListingTrade
1367  SecondaryListingTrade = 55,
1368 
1369  /// RequestForCrossTrade
1370  RequestForCrossTrade = 56,
1371 
1372  /// RequestForCrossStrategyLegTrade
1373  RequestForCrossStrategyLegTrade = 57,
1374 
1375  /// NewBidWithLiquidityProvider
1376  NewBidWithLiquidityProvider = 58,
1377 
1378  /// NewOfferWithLiquidityProvider
1379  NewOfferWithLiquidityProvider = 59,
1380 
1381  /// UpdatedBidWithLiquidityProvider
1382  UpdatedBidWithLiquidityProvider = 60,
1383 
1384  /// UpdatedOfferWithLiquidityProvider
1385  UpdatedOfferWithLiquidityProvider = 61,
1386 
1387  /// LowStaticCollar
1388  LowStaticCollar = 63,
1389 
1390  /// HighStaticCollar
1391  HighStaticCollar = 64,
1392 
1393  /// MarketVWAPOperationTrade
1394  MarketVWAPOperationTrade = 65,
1395 
1396  /// RequestForSizeBid
1397  RequestForSizeBid = 66,
1398 
1399  /// RequestForSizeOffer
1400  RequestForSizeOffer = 67,
1401 
1402  /// LowLPCollar
1403  LowLPCollar = 70,
1404 
1405  /// HighLPCollar
1406  HighLPCollar = 71,
1407 
1408  /// ETFMTFNAVTradePriceInBp
1409  ETFMTFNAVTradePriceInBp = 72,
1410 
1411  /// ETFMTFNAVDarkTradePriceInBp
1412  ETFMTFNAVDarkTradePriceInBp = 73,
1413 
1414  /// NewBidOnWholesaleRFC
1415  NewBidOnWholesaleRFC = 74,
1416 
1417  /// NewOfferOnWholesaleRFC
1418  NewOfferOnWholesaleRFC = 75,
1419 
1420  /// UpdatedBidOnWholesaleRFC
1421  UpdatedBidOnWholesaleRFC = 76,
1422 
1423  /// UpdatedOfferOnWholesaleRFC
1424  UpdatedOfferOnWholesaleRFC = 77,
1425 
1426  /// ClearWholesaleRFC
1427  ClearWholesaleRFC = 78,
1428 
1429  /// GuaranteedCrossNegotiatedDealNLIQ
1430  GuaranteedCrossNegotiatedDealNLIQ = 79,
1431 
1432  /// GuaranteedCrossNegotiatedDealOILQ
1433  GuaranteedCrossNegotiatedDealOILQ = 80,
1434 
1435  /// LargeInScaleTrade
1436  LargeInScaleTrade = 81,
1437 
1438  /// LargeInScaleTradeInBasisPoints
1439  LargeInScaleTradeInBasisPoints = 82,
1440 
1441  /// LargeInScalePackageTradeInBasisPoints
1442  LargeInScalePackageTradeInBasisPoints = 83,
1443 
1444  /// StrategyLegLargeInScaleTradeInBasisPoints
1445  StrategyLegLargeInScaleTradeInBasisPoints = 84,
1446 
1447  /// NewBidRFQAnswer
1448  NewBidRFQAnswer = 86,
1449 
1450  /// NewOfferRFQAnswer
1451  NewOfferRFQAnswer = 87,
1452 
1453  /// UpdatedBidRFQAnswer
1454  UpdatedBidRFQAnswer = 88,
1455 
1456  /// UpdatedOfferRFQAnswer
1457  UpdatedOfferRFQAnswer = 89,
1458 
1459  /// BidExecutionSummary
1460  BidExecutionSummary = 90,
1461 
1462  /// AQSExpansionFactor
1463  AQSExpansionFactor = 91,
1464 
1465  /// CollarsExpansionFactor
1466  CollarsExpansionFactor = 92,
1467 
1468  /// CollarsEnabled
1469  CollarsEnabled = 93,
1470 
1471  /// CollarsDisabled
1472  CollarsDisabled = 94,
1473 
1474  /// DCRPInterMonthSpread
1475  DCRPInterMonthSpread = 95,
1476 
1477  /// FSPReferencePrice
1478  FSPReferencePrice = 96,
1479 
1480  /// OfferExecutionSummary
1481  OfferExecutionSummary = 97,
1482 
1483  /// FSPTriggered
1484  FSPTriggered = 98,
1485 
1486  /// MidPointBBO
1487  MidPointBBO = 99,
1488 
1489  /// ConventionalTradeProvisionalPrice
1490  ConventionalTradeProvisionalPrice = 100,
1491 
1492  /// HighOrderPriceControlCollar
1493  HighOrderPriceControlCollar = 101,
1494 
1495  /// LowOrderPriceControlCollar
1496  LowOrderPriceControlCollar = 102,
1497 
1498  /// OrderPriceControlCollarReferencePrice
1499  OrderPriceControlCollarReferencePrice = 103,
1500 
1501  /// IssuingOrTenderOfferTrade
1502  IssuingOrTenderOfferTrade = 104,
1503 
1504  /// RFQTrade
1505  RFQTrade = 105,
1506 
1507  /// FLIPSpread
1508  FLIPSpread = 106,
1509 
1510  /// FLIPReferencePrice
1511  FLIPReferencePrice = 107,
1512 
1513  /// ClearBook
1514  ClearBook = 254
1515  };
1516 
1517  /// \return a human-readable presentation.
1519  static
1520  std::string
1521  toString(
1522  Enum);
1523 };
1524 
1525 /// `MarketDataChangeType_enum` type.
1527 {
1528  typedef UInt8 Base;
1529 
1530  enum Enum
1531  {
1532  /// StatusChanges
1533  StatusChanges = 0,
1534 
1535  /// ScheduledEventNotification
1536  ScheduledEventNotification = 1,
1537 
1538  /// StatusChangeAndScheduledEventNotification
1539  StatusChangeAndScheduledEventNotification = 2
1540  };
1541 
1542  /// \return a human-readable presentation.
1544  static
1545  std::string
1546  toString(
1547  Enum);
1548 };
1549 
1550 /// `EMM_enum` type.
1552 {
1553  typedef UInt8 Base;
1554 
1555  enum Enum
1556  {
1557  /// CashAndDerivativeCentralOrderBook
1558  CashAndDerivativeCentralOrderBook = 1,
1559 
1560  /// NAVTradingFacility
1561  NAVTradingFacility = 2,
1562 
1563  /// DerivativesWholesales
1564  DerivativesWholesales = 4,
1565 
1566  /// CashOnExchangeOffBook
1567  CashOnExchangeOffBook = 5,
1568 
1569  /// EuronextOffExchangeTradeReports
1570  EuronextOffExchangeTradeReports = 6,
1571 
1572  /// DerivativesOnExchangeOffBook
1573  DerivativesOnExchangeOffBook = 7,
1574 
1575  /// ETFMTFNAVCentralOrderBook
1576  ETFMTFNAVCentralOrderBook = 8,
1577 
1578  /// ListedNotTraded
1579  ListedNotTraded = 9,
1580 
1581  /// DeltaNeutralContingencyLeg
1582  DeltaNeutralContingencyLeg = 15,
1583 
1584  /// NotApplicable
1585  NotApplicable = 99
1586  };
1587 
1588  /// \return a human-readable presentation.
1590  static
1591  std::string
1592  toString(
1593  Enum);
1594 };
1595 
1596 /// `MarketModel_enum` type.
1598 {
1599  typedef UInt8 Base;
1600 
1601  enum Enum
1602  {
1603  /// OrderDriven
1604  OrderDriven = 1,
1605 
1606  /// QuoteDriven
1607  QuoteDriven = 2,
1608 
1609  /// IPO
1610  IPO = 3,
1611 
1612  /// PrimaryMarket
1613  PrimaryMarket = 4,
1614 
1615  /// RFQ
1616  RFQ = 5,
1617 
1618  /// ConditionalUncrossing
1619  ConditionalUncrossing = 6
1620  };
1621 
1622  /// \return a human-readable presentation.
1624  static
1625  std::string
1626  toString(
1627  Enum);
1628 };
1629 
1630 /// `OrderEntryQualifier_enum` type.
1632 {
1633  typedef UInt8 Base;
1634 
1635  enum Enum
1636  {
1637  /// OrderEntryCancelModifyDisabled
1638  OrderEntryCancelModifyDisabled = 0,
1639 
1640  /// OrderEntryCancelModifyEnabled
1641  OrderEntryCancelModifyEnabled = 1,
1642 
1643  /// CancelAndModifyOnly
1644  CancelAndModifyOnly = 2,
1645 
1646  /// CancelOnly
1647  CancelOnly = 3
1648  };
1649 
1650  /// \return a human-readable presentation.
1652  static
1653  std::string
1654  toString(
1655  Enum);
1656 };
1657 
1658 /// `OrderSide_enum` type.
1660 {
1661  typedef UInt8 Base;
1662 
1663  enum Enum
1664  {
1665  /// Buy
1666  Buy = 1,
1667 
1668  /// Sell
1669  Sell = 2,
1670 
1671  /// Cross
1672  Cross = 3
1673  };
1674 
1675  /// \return a human-readable presentation.
1677  static
1678  std::string
1679  toString(
1680  Enum);
1681 };
1682 
1683 /// `OrderType_enum` type.
1685 {
1686  typedef UInt8 Base;
1687 
1688  enum Enum
1689  {
1690  /// Market
1691  Market = 1,
1692 
1693  /// Limit
1694  Limit = 2,
1695 
1696  /// StopMarketOrStopMarketOnQuote
1697  StopMarketOrStopMarketOnQuote = 3,
1698 
1699  /// StopLimitOrStopLimitOnQuote
1700  StopLimitOrStopLimitOnQuote = 4,
1701 
1702  /// PrimaryPeg
1703  PrimaryPeg = 5,
1704 
1705  /// MarketToLimit
1706  MarketToLimit = 6,
1707 
1708  /// MarketPeg
1709  MarketPeg = 7,
1710 
1711  /// MidPointPeg
1712  MidPointPeg = 8,
1713 
1714  /// AveragePrice
1715  AveragePrice = 9,
1716 
1717  /// Iceberg
1718  Iceberg = 10
1719  };
1720 
1721  /// \return a human-readable presentation.
1723  static
1724  std::string
1725  toString(
1726  Enum);
1727 };
1728 
1729 /// `BookState_enum` type.
1731 {
1732  typedef UInt8 Base;
1733 
1734  enum Enum
1735  {
1736  /// Inaccessible
1737  Inaccessible = 1,
1738 
1739  /// Closed
1740  Closed = 2,
1741 
1742  /// Call
1743  Call = 3,
1744 
1745  /// Uncrossing
1746  Uncrossing = 4,
1747 
1748  /// Continuous
1749  Continuous = 5,
1750 
1751  /// Halted
1752  Halted = 6,
1753 
1754  /// ContinuousUncrossing
1755  ContinuousUncrossing = 7,
1756 
1757  /// Suspended
1758  Suspended = 8,
1759 
1760  /// Reserved
1761  Reserved = 9
1762  };
1763 
1764  /// \return a human-readable presentation.
1766  static
1767  std::string
1768  toString(
1769  Enum);
1770 };
1771 
1772 /// `PhaseId_enum` type.
1774 {
1775  typedef UInt8 Base;
1776 
1777  enum Enum
1778  {
1779  /// Inaccessible
1780  Inaccessible = 1,
1781 
1782  /// Closed
1783  Closed = 2,
1784 
1785  /// Call
1786  Call = 3,
1787 
1788  /// Uncrossing
1789  Uncrossing = 4,
1790 
1791  /// Continuous
1792  Continuous = 5,
1793 
1794  /// ContinuousUncrossing
1795  ContinuousUncrossing = 7
1796  };
1797 
1798  /// \return a human-readable presentation.
1800  static
1801  std::string
1802  toString(
1803  Enum);
1804 };
1805 
1806 /// `InstrumentState_enum` type.
1808 {
1809  typedef UInt8 Base;
1810 
1811  enum Enum
1812  {
1813  /// Scheduled
1814  Scheduled = 1,
1815 
1816  /// SuspendedDueToUnderlying
1817  SuspendedDueToUnderlying = 2,
1818 
1819  /// SuspendedKOBI
1820  SuspendedKOBI = 3,
1821 
1822  /// SuspendedKOBE
1823  SuspendedKOBE = 4,
1824 
1825  /// SuspendedNewListing
1826  SuspendedNewListing = 5,
1827 
1828  /// SuspendedByMO
1829  SuspendedByMO = 6,
1830 
1831  /// SuspendedTechnical
1832  SuspendedTechnical = 7,
1833 
1834  /// ReservedDynamicCollars
1835  ReservedDynamicCollars = 8,
1836 
1837  /// ReservedStaticCollars
1838  ReservedStaticCollars = 9,
1839 
1840  /// ReservedWaitingForLP
1841  ReservedWaitingForLP = 10,
1842 
1843  /// ReservedLPLimit
1844  ReservedLPLimit = 11,
1845 
1846  /// InstrumentDeletion
1847  InstrumentDeletion = 12,
1848 
1849  /// SuspendedWaitingForBBO
1850  SuspendedWaitingForBBO = 13,
1851 
1852  /// SuspendedWaitingForTradableState
1853  SuspendedWaitingForTradableState = 14,
1854 
1855  /// RandomUncrossingPeriod
1856  RandomUncrossingPeriod = 15,
1857 
1858  /// Expired
1859  Expired = 16,
1860 
1861  /// Uncrossing
1862  Uncrossing = 17,
1863 
1864  /// ReservedDueToLeg
1865  ReservedDueToLeg = 18,
1866 
1867  /// SuspendedDueToLeg
1868  SuspendedDueToLeg = 19,
1869 
1870  /// ReservedFutureLimitInterruptionProtection
1871  ReservedFutureLimitInterruptionProtection = 21,
1872 
1873  /// SuspendedWaitingForMarketOperations
1874  SuspendedWaitingForMarketOperations = 22
1875  };
1876 
1877  /// \return a human-readable presentation.
1879  static
1880  std::string
1881  toString(
1882  Enum);
1883 };
1884 
1885 /// `TradeType_enum` type.
1887 {
1888  typedef UInt8 Base;
1889 
1890  enum Enum
1891  {
1892  /// ConventionalTrade
1893  ConventionalTrade = 1,
1894 
1895  /// LargeInScaleLiSTrade
1896  LargeInScaleLiSTrade = 2,
1897 
1898  /// BasisTrade
1899  BasisTrade = 3,
1900 
1901  /// LargeInScaleLiSPackageTrade
1902  LargeInScaleLiSPackageTrade = 4,
1903 
1904  /// GuaranteedCrossTrade
1905  GuaranteedCrossTrade = 5,
1906 
1907  /// AgainstActualTrade
1908  AgainstActualTrade = 6,
1909 
1910  /// AssetAllocationTrade
1911  AssetAllocationTrade = 7,
1912 
1913  /// ExchangeForSwapTrade
1914  ExchangeForSwapTrade = 9,
1915 
1916  /// ExchangeForPhysicalTradeCashLeg
1917  ExchangeForPhysicalTradeCashLeg = 10,
1918 
1919  /// StrategyLegConventionalTrade
1920  StrategyLegConventionalTrade = 11,
1921 
1922  /// StrategyLegLargeInScaleLiSTrade
1923  StrategyLegLargeInScaleLiSTrade = 12,
1924 
1925  /// StrategyLegBasisTrade
1926  StrategyLegBasisTrade = 13,
1927 
1928  /// StrategyLegGuaranteedCrossTrade
1929  StrategyLegGuaranteedCrossTrade = 14,
1930 
1931  /// StrategyLegAgainstActualTrade
1932  StrategyLegAgainstActualTrade = 15,
1933 
1934  /// StrategyLegAssetAllocationTrade
1935  StrategyLegAssetAllocationTrade = 16,
1936 
1937  /// StrategyLegExchangeForSwapTrade
1938  StrategyLegExchangeForSwapTrade = 18,
1939 
1940  /// StrategyLegExchangeForPhysicalTrade
1941  StrategyLegExchangeForPhysicalTrade = 19,
1942 
1943  /// BoBTrade
1944  BoBTrade = 20,
1945 
1946  /// AtomXTrade
1947  AtomXTrade = 22,
1948 
1949  /// TradeCancellation
1950  TradeCancellation = 24,
1951 
1952  /// OutOfMarketTrade
1953  OutOfMarketTrade = 25,
1954 
1955  /// DeltaNeutralTradeUnderlyingCashLeg
1956  DeltaNeutralTradeUnderlyingCashLeg = 26,
1957 
1958  /// MarketVWAPOperationTrade
1959  MarketVWAPOperationTrade = 27,
1960 
1961  /// EuronextFundServiceTrade
1962  EuronextFundServiceTrade = 28,
1963 
1964  /// SecondaryListingTrade
1965  SecondaryListingTrade = 29,
1966 
1967  /// RequestForCrossTrade
1968  RequestForCrossTrade = 30,
1969 
1970  /// RequestForCrossStrategyLegTrade
1971  RequestForCrossStrategyLegTrade = 31,
1972 
1973  /// TradePublication
1974  TradePublication = 32,
1975 
1976  /// DarkTrade
1977  DarkTrade = 33,
1978 
1979  /// DeltaNeutralTradeUnderlyingFutureLeg
1980  DeltaNeutralTradeUnderlyingFutureLeg = 34,
1981 
1982  /// TotalTradedVolume
1983  TotalTradedVolume = 36,
1984 
1985  /// ETFMTFNAVTradePriceInBp
1986  ETFMTFNAVTradePriceInBp = 37,
1987 
1988  /// ETFMTFNAVDarkTradePriceInBp
1989  ETFMTFNAVDarkTradePriceInBp = 38,
1990 
1991  /// GuaranteedCrossNegotiatedDealNLIQ
1992  GuaranteedCrossNegotiatedDealNLIQ = 39,
1993 
1994  /// GuaranteedCrossNegotiatedDealOILQ
1995  GuaranteedCrossNegotiatedDealOILQ = 40,
1996 
1997  /// LargeInScaleTrade
1998  LargeInScaleTrade = 41,
1999 
2000  /// LargeInScaleTradeInBasisPoints
2001  LargeInScaleTradeInBasisPoints = 42,
2002 
2003  /// LargeInScalePackageTradeInBasisPoints
2004  LargeInScalePackageTradeInBasisPoints = 43,
2005 
2006  /// StrategyLegLargeInScaleTradeInBasisPoints
2007  StrategyLegLargeInScaleTradeInBasisPoints = 44,
2008 
2009  /// TradeReversal
2010  TradeReversal = 45,
2011 
2012  /// NonStandardSettlement
2013  NonStandardSettlement = 46,
2014 
2015  /// RepurchaseAgreementRepo
2016  RepurchaseAgreementRepo = 47,
2017 
2018  /// ExchangeGrantedTrade
2019  ExchangeGrantedTrade = 48,
2020 
2021  /// Other
2022  Other = 49,
2023 
2024  /// OddLot
2025  OddLot = 50,
2026 
2027  /// ConventionalTradeProvisionalPrice
2028  ConventionalTradeProvisionalPrice = 100,
2029 
2030  /// LargeInScaleLiSTradeProvisionalPrice
2031  LargeInScaleLiSTradeProvisionalPrice = 101,
2032 
2033  /// LargeInScaleLiSPackageTradeProvisionalPrice
2034  LargeInScaleLiSPackageTradeProvisionalPrice = 102,
2035 
2036  /// IssuingOrTenderOfferTrade
2037  IssuingOrTenderOfferTrade = 103,
2038 
2039  /// RFQTrade
2040  RFQTrade = 104
2041  };
2042 
2043  /// \return a human-readable presentation.
2045  static
2046  std::string
2047  toString(
2048  Enum);
2049 };
2050 
2051 /// `TradingPeriod_enum` type.
2053 {
2054  typedef UInt8 Base;
2055 
2056  enum Enum
2057  {
2058  /// Opening
2059  Opening = 1,
2060 
2061  /// Standard
2062  Standard = 2,
2063 
2064  /// Closing
2065  Closing = 3
2066  };
2067 
2068  /// \return a human-readable presentation.
2070  static
2071  std::string
2072  toString(
2073  Enum);
2074 };
2075 
2076 /// `TradingSide_enum` type.
2078 {
2079  typedef UInt8 Base;
2080 
2081  enum Enum
2082  {
2083  /// BidOnly
2084  BidOnly = 1,
2085 
2086  /// OfferOnly
2087  OfferOnly = 2,
2088 
2089  /// PAKO
2090  PAKO = 3,
2091 
2092  /// BothSides
2093  BothSides = 4
2094  };
2095 
2096  /// \return a human-readable presentation.
2098  static
2099  std::string
2100  toString(
2101  Enum);
2102 };
2103 
2104 /// `PriceLimits_enum` type.
2106 {
2107  typedef UInt8 Base;
2108 
2109  enum Enum
2110  {
2111  /// PriceLimitsEnabledNormal
2112  PriceLimitsEnabledNormal = 1,
2113 
2114  /// PriceLimitsEnabledWide
2115  PriceLimitsEnabledWide = 2,
2116 
2117  /// PriceLimitsEnabledWidest
2118  PriceLimitsEnabledWidest = 3,
2119 
2120  /// PriceLimitsDisabled
2121  PriceLimitsDisabled = 4
2122  };
2123 
2124  /// \return a human-readable presentation.
2126  static
2127  std::string
2128  toString(
2129  Enum);
2130 };
2131 
2132 /// `QuoteSpreadMultiplier_enum` type.
2134 {
2135  typedef UInt8 Base;
2136 
2137  enum Enum
2138  {
2139  /// QuoteSpreadMultiplier1
2140  QuoteSpreadMultiplier1 = 1,
2141 
2142  /// QuoteSpreadMultiplier2
2143  QuoteSpreadMultiplier2 = 2,
2144 
2145  /// QuoteSpreadMultiplier3
2146  QuoteSpreadMultiplier3 = 3
2147  };
2148 
2149  /// \return a human-readable presentation.
2151  static
2152  std::string
2153  toString(
2154  Enum);
2155 };
2156 
2157 /// `ExchangeCode_enum` type.
2159 {
2160  typedef Char Base;
2161 
2162  enum Enum
2163  {
2164  /// AmsterdamEquityDerivatives
2165  AmsterdamEquityDerivatives = 'A',
2166 
2167  /// BrusselsEquityDerivatives
2168  BrusselsEquityDerivatives = 'B',
2169 
2170  /// ParisEquityUnderlyings
2171  ParisEquityUnderlyings = 'C',
2172 
2173  /// BrusselsCashUnderlyings
2174  BrusselsCashUnderlyings = 'D',
2175 
2176  /// BrusselsIndexDerivatives
2177  BrusselsIndexDerivatives = 'F',
2178 
2179  /// AmsterdamCashUnderlyings
2180  AmsterdamCashUnderlyings = 'G',
2181 
2182  /// LisbonCashUnderlyings
2183  LisbonCashUnderlyings = 'H',
2184 
2185  /// ParisIndexDerivatives
2186  ParisIndexDerivatives = 'J',
2187 
2188  /// AmsterdamIndexDerivatives
2189  AmsterdamIndexDerivatives = 'K',
2190 
2191  /// LisbonIndexDerivatives
2192  LisbonIndexDerivatives = 'M',
2193 
2194  /// ParisEquityDerivatives
2195  ParisEquityDerivatives = 'P',
2196 
2197  /// AmsterdamCommoditiesDerivatives
2198  AmsterdamCommoditiesDerivatives = 'R',
2199 
2200  /// LisbonEquityDerivatives
2201  LisbonEquityDerivatives = 'S',
2202 
2203  /// ParisCommoditiesDerivatives
2204  ParisCommoditiesDerivatives = 'Y',
2205 
2206  /// AmsterdamCurrencyDerivatives
2207  AmsterdamCurrencyDerivatives = 'Z',
2208 
2209  /// OsloIndexDerivatives
2210  OsloIndexDerivatives = 'N',
2211 
2212  /// OsloEquityDerivatives
2213  OsloEquityDerivatives = 'O',
2214 
2215  /// OsloCashUnderlying
2216  OsloCashUnderlying = 'L',
2217 
2218  /// MilanCashUnderlying
2219  MilanCashUnderlying = 'U',
2220 
2221  /// MilanIndexDerivatives
2222  MilanIndexDerivatives = 'I',
2223 
2224  /// MilanEquityDerivatives
2225  MilanEquityDerivatives = 'E',
2226 
2227  /// MilanInterestRateDerivatives
2228  MilanInterestRateDerivatives = 'T'
2229  };
2230 
2231  /// \return a human-readable presentation.
2233  static
2234  std::string
2235  toString(
2236  Enum);
2237 };
2238 
2239 /// `LegBuyorSell_enum` type.
2241 {
2242  typedef Char Base;
2243 
2244  enum Enum
2245  {
2246  /// Buy
2247  Buy = 'B',
2248 
2249  /// Sell
2250  Sell = 'S'
2251  };
2252 
2253  /// \return a human-readable presentation.
2255  static
2256  std::string
2257  toString(
2258  Enum);
2259 };
2260 
2261 /// `OptiqSegment_enum` type.
2263 {
2264  typedef UInt8 Base;
2265 
2266  enum Enum
2267  {
2268  /// Equities
2269  Equities = 1,
2270 
2271  /// Funds
2272  Funds = 2,
2273 
2274  /// FixedIncome
2275  FixedIncome = 3,
2276 
2277  /// WarrantsAndCertificates
2278  WarrantsAndCertificates = 4,
2279 
2280  /// BourseDeLuxembourg
2281  BourseDeLuxembourg = 5,
2282 
2283  /// Options
2284  Options = 6,
2285 
2286  /// Futures
2287  Futures = 7,
2288 
2289  /// Commodities
2290  Commodities = 8,
2291 
2292  /// Indices
2293  Indices = 9,
2294 
2295  /// TradeReportingAndPublication
2296  TradeReportingAndPublication = 10,
2297 
2298  /// Block
2299  Block = 14,
2300 
2301  /// IndexDerivatives
2302  IndexDerivatives = 11,
2303 
2304  /// EquityDerivatives
2305  EquityDerivatives = 12,
2306 
2307  /// FinancialDerivatives
2308  FinancialDerivatives = 13,
2309 
2310  /// Forex
2311  Forex = 15,
2312 
2313  /// IBF
2314  IBF = 16
2315  };
2316 
2317  /// \return a human-readable presentation.
2319  static
2320  std::string
2321  toString(
2322  Enum);
2323 };
2324 
2325 /// `OptionType_enum` type.
2327 {
2328  typedef UInt8 Base;
2329 
2330  enum Enum
2331  {
2332  /// Call
2333  Call = 1,
2334 
2335  /// Put
2336  Put = 2,
2337 
2338  /// Other
2339  Other = 3
2340  };
2341 
2342  /// \return a human-readable presentation.
2344  static
2345  std::string
2346  toString(
2347  Enum);
2348 };
2349 
2350 /// `IndexLevelType_enum` type.
2352 {
2353  typedef UInt8 Base;
2354 
2355  enum Enum
2356  {
2357  /// IndicativeIndex
2358  IndicativeIndex = 0,
2359 
2360  /// OfficialOpeningIndex
2361  OfficialOpeningIndex = 1,
2362 
2363  /// RealTimeIndex
2365 
2366  /// AutomaticIndicativeIndex
2367  AutomaticIndicativeIndex = 3,
2368 
2369  /// PreliminaryReferenceIndex
2370  PreliminaryReferenceIndex = 4,
2371 
2372  /// ClosingReferenceIndex
2373  ClosingReferenceIndex = 5,
2374 
2375  /// ConfirmedReferenceIndex
2376  ConfirmedReferenceIndex = 6,
2377 
2378  /// OptionsLiquidationIndex
2379  OptionsLiquidationIndex = 7
2380  };
2381 
2382  /// \return a human-readable presentation.
2384  static
2385  std::string
2386  toString(
2387  Enum);
2388 };
2389 
2390 /// `TransactionType_enum` type.
2392 {
2393  typedef UInt8 Base;
2394 
2395  enum Enum
2396  {
2397  /// PlainVanillaTrade
2398  PlainVanillaTrade = 1,
2399 
2400  /// DarkTrade
2401  DarkTrade = 2,
2402 
2403  /// BenchmarkTrade
2404  BenchmarkTrade = 3,
2405 
2406  /// TechnicalTrade
2407  TechnicalTrade = 4,
2408 
2409  /// GiveupGiveinTrade
2410  GiveupGiveinTrade = 5,
2411 
2412  /// ExCumDividendTrade
2413  ExCumDividendTrade = 6,
2414 
2415  /// TradeWithCondition
2416  TradeWithCondition = 7,
2417 
2418  /// SummaryReport
2419  SummaryReport = 15
2420  };
2421 
2422  /// \return a human-readable presentation.
2424  static
2425  std::string
2426  toString(
2427  Enum);
2428 };
2429 
2430 /// `BlockTradeCode_enum` type.
2432 {
2433  typedef Char Base;
2434 
2435  enum Enum
2436  {
2437  /// BlockTrade
2438  BlockTrade = 'B',
2439 
2440  /// RegularTradeOrNegotiatedDeal
2441  RegularTradeOrNegotiatedDeal = 'N',
2442 
2443  /// Undefined
2444  Undefined = '-'
2445  };
2446 
2447  /// \return a human-readable presentation.
2449  static
2450  std::string
2451  toString(
2452  Enum);
2453 };
2454 
2455 /// `EffectiveDateIndicator_enum` type.
2457 {
2458  typedef UInt8 Base;
2459 
2460  enum Enum
2461  {
2462  /// SellerDeclarationIsReceivedOnTheCurTradingSessionDay
2463  SellerDeclarationIsReceivedOnTheCurTradingSessionDay = 0,
2464 
2465  /// SellerDeclarationReceivedBeforeTheCurTradingSessionDay
2466  SellerDeclarationReceivedBeforeTheCurTradingSessionDay = 1
2467  };
2468 
2469  /// \return a human-readable presentation.
2471  static
2472  std::string
2473  toString(
2474  Enum);
2475 };
2476 
2477 /// `IndexPriceCode_enum` type.
2479 {
2480  typedef UInt8 Base;
2481 
2482  enum Enum
2483  {
2484  /// OnlyIndex
2485  OnlyIndex = 0,
2486 
2487  /// IndexAndSessionHigh
2488  IndexAndSessionHigh = 1,
2489 
2490  /// IndexAndSessionLow
2491  IndexAndSessionLow = 2,
2492 
2493  /// IndexAndSessionHighAndLowTypicallyFirstPrice
2494  IndexAndSessionHighAndLowTypicallyFirstPrice = 3,
2495 
2496  /// OnlySessionHigh
2497  OnlySessionHigh = 4,
2498 
2499  /// OnlySessionLow
2500  OnlySessionLow = 5,
2501 
2502  /// PreviousDayClose
2503  PreviousDayClose = 6
2504  };
2505 
2506  /// \return a human-readable presentation.
2508  static
2509  std::string
2510  toString(
2511  Enum);
2512 };
2513 
2514 /// `StatsUpdateType_enum` type.
2516 {
2517  typedef UInt8 Base;
2518 
2519  enum Enum
2520  {
2521  /// DailyHigh
2522  DailyHigh = 5,
2523 
2524  /// DailyLow
2525  DailyLow = 6,
2526 
2527  /// YearlyHigh
2528  YearlyHigh = 7,
2529 
2530  /// YearlyLow
2531  YearlyLow = 8,
2532 
2533  /// LifetimeHigh
2534  LifetimeHigh = 9,
2535 
2536  /// LifetimeLow
2537  LifetimeLow = 10,
2538 
2539  /// VariationLastPrice
2540  VariationLastPrice = 14,
2541 
2542  /// OpenPrice
2543  OpenPrice = 15,
2544 
2545  /// TradeCount
2546  TradeCount = 16,
2547 
2548  /// LastTradedPrice
2549  LastTradedPrice = 17,
2550 
2551  /// PercentVariationPreviousClose
2552  PercentVariationPreviousClose = 18,
2553 
2554  /// OffBookCumulQty
2555  OffBookCumulQty = 19,
2556 
2557  /// OnBookAuctionCumulQty
2558  OnBookAuctionCumulQty = 21,
2559 
2560  /// OnBookContinuousCumulQty
2561  OnBookContinuousCumulQty = 22,
2562 
2563  /// OnAndOffBookCumulQty
2564  OnAndOffBookCumulQty = 23
2565  };
2566 
2567  /// \return a human-readable presentation.
2569  static
2570  std::string
2571  toString(
2572  Enum);
2573 };
2574 
2575 /// `GuaranteeIndicator_enum` type.
2577 {
2578  typedef UInt8 Base;
2579 
2580  enum Enum
2581  {
2582  /// ThisInstrumentIsNotGuaranteed
2583  ThisInstrumentIsNotGuaranteed = 0,
2584 
2585  /// ThisInstrumentIsGuaranteed
2586  ThisInstrumentIsGuaranteed = 1,
2587 
2588  /// ThisInstrumentIsNotClearable
2589  ThisInstrumentIsNotClearable = 2,
2590 
2591  /// GuaranteedClearedBorrowingLendingService
2592  GuaranteedClearedBorrowingLendingService = 8
2593  };
2594 
2595  /// \return a human-readable presentation.
2597  static
2598  std::string
2599  toString(
2600  Enum);
2601 };
2602 
2603 /// `MMTMarketMechanism_enum` type.
2605 {
2606  typedef UInt8 Base;
2607 
2608  enum Enum
2609  {
2610  /// CentralLimitOrderBook
2611  CentralLimitOrderBook = 1,
2612 
2613  /// QuoteDrivenMarket
2614  QuoteDrivenMarket = 2,
2615 
2616  /// DarkOrderBook
2617  DarkOrderBook = 3,
2618 
2619  /// OffBookIncludingVoiceOrMessagingTrading
2620  OffBookIncludingVoiceOrMessagingTrading = 4,
2621 
2622  /// PeriodicAuctionEqualUncrossing
2623  PeriodicAuctionEqualUncrossing = 5,
2624 
2625  /// RequestForQuotes
2626  RequestForQuotes = 6,
2627 
2628  /// HybridSystem
2629  HybridSystem = 8,
2630 
2631  /// AnyOtherExcludingHybrid
2632  AnyOtherExcludingHybrid = 9
2633  };
2634 
2635  /// \return a human-readable presentation.
2637  static
2638  std::string
2639  toString(
2640  Enum);
2641 };
2642 
2643 /// `EfficientMMTMarketMechanism_enum` type.
2645 {
2646  typedef UInt8 Base;
2647 
2648  enum Enum
2649  {
2650  /// CentralLimitOrderBook
2651  CentralLimitOrderBook = 1,
2652 
2653  /// QuoteDrivenMarket
2654  QuoteDrivenMarket = 2,
2655 
2656  /// DarkOrderBook
2657  DarkOrderBook = 3,
2658 
2659  /// OffBookIncludingVoiceOrMessagingTrading
2660  OffBookIncludingVoiceOrMessagingTrading = 4,
2661 
2662  /// PeriodicAuctionEqualUncrossing
2663  PeriodicAuctionEqualUncrossing = 5,
2664 
2665  /// RequestForQuotes
2666  RequestForQuotes = 6,
2667 
2668  /// Other
2669  Other = 7
2670  };
2671 
2672  /// \return a human-readable presentation.
2674  static
2675  std::string
2676  toString(
2677  Enum);
2678 };
2679 
2680 /// `MMTTradingMode_enum` type.
2682 {
2683  typedef Char Base;
2684 
2685  enum Enum
2686  {
2687  /// UndefinedAuctionEqualUncrossing
2688  UndefinedAuctionEqualUncrossing = '1',
2689 
2690  /// ContinuousTrading
2691  ContinuousTrading = '2',
2692 
2693  /// AtMarketCloseTrading
2694  AtMarketCloseTrading = '3',
2695 
2696  /// OutOfMainSessionTrading
2697  OutOfMainSessionTrading = '4',
2698 
2699  /// TradeReportingOnExchange
2700  TradeReportingOnExchange = '5',
2701 
2702  /// TradeReportingOffExchange
2703  TradeReportingOffExchange = '6',
2704 
2705  /// TradeReportingSystematicInternaliser
2706  TradeReportingSystematicInternaliser = '7',
2707 
2708  /// ScheduledIntradayAuctionEqualUncrossing
2709  ScheduledIntradayAuctionEqualUncrossing = 'I',
2710 
2711  /// ScheduledClosingAuctionEqualUncrossing
2712  ScheduledClosingAuctionEqualUncrossing = 'K',
2713 
2714  /// ScheduledOpeningAuctionEqualUncrossing
2715  ScheduledOpeningAuctionEqualUncrossing = 'O',
2716 
2717  /// UnscheduledAuctionEqualUncrossing
2718  UnscheduledAuctionEqualUncrossing = 'U',
2719 
2720  /// OnDemandAuctionEqualFrequentBatchedAuction
2721  OnDemandAuctionEqualFrequentBatchedAuction = 'P'
2722  };
2723 
2724  /// \return a human-readable presentation.
2726  static
2727  std::string
2728  toString(
2729  Enum);
2730 };
2731 
2732 /// `EfficientMMTTradingMode_enum` type.
2734 {
2735  typedef Char Base;
2736 
2737  enum Enum
2738  {
2739  /// UndefinedAuctionEqualUncrossing
2740  UndefinedAuctionEqualUncrossing = '1',
2741 
2742  /// ContinuousTrading
2743  ContinuousTrading = '2',
2744 
2745  /// AtMarketCloseTrading
2746  AtMarketCloseTrading = '3',
2747 
2748  /// OutOfMainSessionTrading
2749  OutOfMainSessionTrading = '4',
2750 
2751  /// TradeReportingOnExchange
2752  TradeReportingOnExchange = '5',
2753 
2754  /// TradeReportingOffExchange
2755  TradeReportingOffExchange = '6',
2756 
2757  /// TradeReportingSystematicInternaliser
2758  TradeReportingSystematicInternaliser = '7',
2759 
2760  /// ScheduledIntradayAuctionEqualUncrossing
2761  ScheduledIntradayAuctionEqualUncrossing = 'I',
2762 
2763  /// ScheduledClosingAuctionEqualUncrossing
2764  ScheduledClosingAuctionEqualUncrossing = 'K',
2765 
2766  /// ScheduledOpeningAuctionEqualUncrossing
2767  ScheduledOpeningAuctionEqualUncrossing = 'O',
2768 
2769  /// UnscheduledAuctionEqualUncrossing
2770  UnscheduledAuctionEqualUncrossing = 'U',
2771 
2772  /// OnDemandAuctionEqualFrequentBatchedAuction
2773  OnDemandAuctionEqualFrequentBatchedAuction = 'P'
2774  };
2775 
2776  /// \return a human-readable presentation.
2778  static
2779  std::string
2780  toString(
2781  Enum);
2782 };
2783 
2784 /// `EfficientMMTTransactionCategory_enum` type.
2786 {
2787  typedef Char Base;
2788 
2789  enum Enum
2790  {
2791  /// DarkTrade
2792  DarkTrade = 'D',
2793 
2794  /// RPRI
2795  RPRI = 'R',
2796 
2797  /// XFPH
2798  XFPH = 'Y',
2799 
2800  /// TPAC
2801  TPAC = 'Z',
2802 
2803  /// NoneApply
2804  NoneApply = '-'
2805  };
2806 
2807  /// \return a human-readable presentation.
2809  static
2810  std::string
2811  toString(
2812  Enum);
2813 };
2814 
2815 /// `EfficientMMTNegotiationIndicator_enum` type.
2817 {
2818  typedef Char Base;
2819 
2820  enum Enum
2821  {
2822  /// NLIQ
2823  NLIQ = '1',
2824 
2825  /// OILQ
2826  OILQ = '2',
2827 
2828  /// PRIC
2829  PRIC = '3',
2830 
2831  /// ILQD
2832  ILQD = '4',
2833 
2834  /// SIZE
2835  SIZE = '5',
2836 
2837  /// ILQDSIZE
2838  ILQDSIZE = '6',
2839 
2840  /// NegotiatedTrade
2841  NegotiatedTrade = 'N',
2842 
2843  /// NoNegotiatedTrade
2844  NoNegotiatedTrade = '-'
2845  };
2846 
2847  /// \return a human-readable presentation.
2849  static
2850  std::string
2851  toString(
2852  Enum);
2853 };
2854 
2855 /// `EfficientMMTAgencyCrossTradeIndicator_enum` type.
2857 {
2858  typedef Char Base;
2859 
2860  enum Enum
2861  {
2862  /// ACTX
2863  ACTX = 'X',
2864 
2865  /// NoAgencyCrossTrade
2866  NoAgencyCrossTrade = '-'
2867  };
2868 
2869  /// \return a human-readable presentation.
2871  static
2872  std::string
2873  toString(
2874  Enum);
2875 };
2876 
2877 /// `EfficientMMTModificationIndicator_enum` type.
2879 {
2880  typedef Char Base;
2881 
2882  enum Enum
2883  {
2884  /// AMND
2885  AMND = 'A',
2886 
2887  /// CANC
2888  CANC = 'C',
2889 
2890  /// NewTrade
2891  NewTrade = '-'
2892  };
2893 
2894  /// \return a human-readable presentation.
2896  static
2897  std::string
2898  toString(
2899  Enum);
2900 };
2901 
2902 /// `EfficientMMTBenchmarkIndicator_enum` type.
2904 {
2905  typedef Char Base;
2906 
2907  enum Enum
2908  {
2909  /// BENC
2910  BENC = 'B',
2911 
2912  /// RFPT
2913  RFPT = 'S',
2914 
2915  /// NoBenchmarkOrReferencePriceTrade
2916  NoBenchmarkOrReferencePriceTrade = '-'
2917  };
2918 
2919  /// \return a human-readable presentation.
2921  static
2922  std::string
2923  toString(
2924  Enum);
2925 };
2926 
2927 /// `EfficientMMTSpecialDividendIndicator_enum` type.
2929 {
2930  typedef Char Base;
2931 
2932  enum Enum
2933  {
2934  /// SDIV
2935  SDIV = 'E',
2936 
2937  /// NoSpecialDividendTrade
2938  NoSpecialDividendTrade = '-'
2939  };
2940 
2941  /// \return a human-readable presentation.
2943  static
2944  std::string
2945  toString(
2946  Enum);
2947 };
2948 
2949 /// `MMTOffBookAutomatedIndicator_enum` type.
2951 {
2952  typedef Char Base;
2953 
2954  enum Enum
2955  {
2956  /// OffBookNonAutomated
2957  OffBookNonAutomated = 'M',
2958 
2959  /// OffBookAutomated
2960  OffBookAutomated = 'Q',
2961 
2962  /// UnspecifiedOrDoesNotApply
2963  UnspecifiedOrDoesNotApply = '-'
2964  };
2965 
2966  /// \return a human-readable presentation.
2968  static
2969  std::string
2970  toString(
2971  Enum);
2972 };
2973 
2974 /// `EfficientMMTOffBookAutomatedIndicator_enum` type.
2976 {
2977  typedef Char Base;
2978 
2979  enum Enum
2980  {
2981  /// OffBookNonAutomated
2982  OffBookNonAutomated = 'M',
2983 
2984  /// OffBookAutomated
2985  OffBookAutomated = 'Q',
2986 
2987  /// UnspecifiedOrDoesNotApply
2988  UnspecifiedOrDoesNotApply = '-'
2989  };
2990 
2991  /// \return a human-readable presentation.
2993  static
2994  std::string
2995  toString(
2996  Enum);
2997 };
2998 
2999 /// `EfficientMMTContributiontoPrice_enum` type.
3001 {
3002  typedef Char Base;
3003 
3004  enum Enum
3005  {
3006  /// TNCP
3007  TNCP = 'J',
3008 
3009  /// PNDG
3010  PNDG = 'N',
3011 
3012  /// PlainVanillaTrade
3013  PlainVanillaTrade = 'P',
3014 
3015  /// NPFT
3016  NPFT = 'T'
3017  };
3018 
3019  /// \return a human-readable presentation.
3021  static
3022  std::string
3023  toString(
3024  Enum);
3025 };
3026 
3027 /// `EfficientMMTAlgorithmicIndicator_enum` type.
3029 {
3030  typedef Char Base;
3031 
3032  enum Enum
3033  {
3034  /// ALGO
3035  ALGO = 'H',
3036 
3037  /// NoAlgorithmicTrade
3038  NoAlgorithmicTrade = '-'
3039  };
3040 
3041  /// \return a human-readable presentation.
3043  static
3044  std::string
3045  toString(
3046  Enum);
3047 };
3048 
3049 /// `EfficientMMTPublicationMode_enum` type.
3051 {
3052  typedef Char Base;
3053 
3054  enum Enum
3055  {
3056  /// NonImmediatePublication
3057  NonImmediatePublication = '1',
3058 
3059  /// LRGS
3060  LRGS = '2',
3061 
3062  /// ILQD
3063  ILQD = '3',
3064 
3065  /// SIZE
3066  SIZE = '4',
3067 
3068  /// ILQDSIZE
3069  ILQDSIZE = '5',
3070 
3071  /// ILQDLRGS
3072  ILQDLRGS = '6',
3073 
3074  /// ImmediatePublication
3075  ImmediatePublication = '-'
3076  };
3077 
3078  /// \return a human-readable presentation.
3080  static
3081  std::string
3082  toString(
3083  Enum);
3084 };
3085 
3086 /// `EfficientMMTPostTradeDeferral_enum` type.
3088 {
3089  typedef Char Base;
3090 
3091  enum Enum
3092  {
3093  /// LMTF
3094  LMTF = '1',
3095 
3096  /// DATF
3097  DATF = '2',
3098 
3099  /// VOLO
3100  VOLO = '3',
3101 
3102  /// FWAF
3103  FWAF = '4',
3104 
3105  /// IDAF
3106  IDAF = '5',
3107 
3108  /// VOLW
3109  VOLW = '6',
3110 
3111  /// FULF
3112  FULF = '7',
3113 
3114  /// FULA
3115  FULA = '8',
3116 
3117  /// FULV
3118  FULV = '9',
3119 
3120  /// FULJ
3121  FULJ = 'V',
3122 
3123  /// COAF
3124  COAF = 'W',
3125 
3126  /// NotApplicable
3127  NotApplicable = '-'
3128  };
3129 
3130  /// \return a human-readable presentation.
3132  static
3133  std::string
3134  toString(
3135  Enum);
3136 };
3137 
3138 /// `EfficientMMTDuplicativeIndicator_enum` type.
3140 {
3141  typedef Char Base;
3142 
3143  enum Enum
3144  {
3145  /// DUPL
3146  DUPL = '1',
3147 
3148  /// UniqueTradeReport
3149  UniqueTradeReport = '-'
3150  };
3151 
3152  /// \return a human-readable presentation.
3154  static
3155  std::string
3156  toString(
3157  Enum);
3158 };
3159 
3160 /// `TransparencyIndicator_enum` type.
3162 {
3163  typedef UInt8 Base;
3164 
3165  enum Enum
3166  {
3167  /// LitRegularTrade
3168  LitRegularTrade = 0,
3169 
3170  /// DarkTradeAndImmediatePublication
3171  DarkTradeAndImmediatePublication = 1,
3172 
3173  /// DarkTradeAndDeferredPublication
3174  DarkTradeAndDeferredPublication = 2
3175  };
3176 
3177  /// \return a human-readable presentation.
3179  static
3180  std::string
3181  toString(
3182  Enum);
3183 };
3184 
3185 /// `MiFIDInstrumentCategory_enum` type.
3187 {
3188  typedef UInt8 Base;
3189 
3190  enum Enum
3191  {
3192  /// NotApplicable
3193  NotApplicable = 0,
3194 
3195  /// RTS1EquityInstrumentFollowingMiFIDDefinition
3196  RTS1EquityInstrumentFollowingMiFIDDefinition = 1,
3197 
3198  /// RTS2NonEquityInstrumentFollowingMiFIDDefinition
3199  RTS2NonEquityInstrumentFollowingMiFIDDefinition = 2
3200  };
3201 
3202  /// \return a human-readable presentation.
3204  static
3205  std::string
3206  toString(
3207  Enum);
3208 };
3209 
3210 /// `DynamicCollarLogic_enum` type.
3212 {
3213  typedef UInt8 Base;
3214 
3215  enum Enum
3216  {
3217  /// NotActive
3218  NotActive = 0,
3219 
3220  /// NoHaltWithReject
3221  NoHaltWithReject = 2,
3222 
3223  /// HaltWithAcceptation
3224  HaltWithAcceptation = 3
3225  };
3226 
3227  /// \return a human-readable presentation.
3229  static
3230  std::string
3231  toString(
3232  Enum);
3233 };
3234 
3235 /// `ReferencePriceOrigin_enum` type.
3237 {
3238  typedef UInt8 Base;
3239 
3240  enum Enum
3241  {
3242  /// Internal
3243  Internal = 1,
3244 
3245  /// External
3246  External = 2,
3247 
3248  /// ExternalBBO
3249  ExternalBBO = 3,
3250 
3251  /// OpeningCallPrice
3252  OpeningCallPrice = 4,
3253 
3254  /// MidBBOOrFairValue
3255  MidBBOOrFairValue = 5,
3256 
3257  /// FairValue
3258  FairValue = 6,
3259 
3260  /// FutureMarketPrice
3261  FutureMarketPrice = 7
3262  };
3263 
3264  /// \return a human-readable presentation.
3266  static
3267  std::string
3268  toString(
3269  Enum);
3270 };
3271 
3272 /// `TaxCode_enum` type.
3274 {
3275  typedef UInt8 Base;
3276 
3277  enum Enum
3278  {
3279  /// NotEligibleToPEATheStockHasNeverBeenAMonoryStock
3280  NotEligibleToPEATheStockHasNeverBeenAMonoryStock = 0,
3281 
3282  /// EligibleToPEA
3283  EligibleToPEA = 3,
3284 
3285  /// NotProvided
3286  NotProvided = 9
3287  };
3288 
3289  /// \return a human-readable presentation.
3291  static
3292  std::string
3293  toString(
3294  Enum);
3295 };
3296 
3297 /// `TypeOfMarketAdmission_enum` type.
3299 {
3300  typedef Char Base;
3301 
3302  enum Enum
3303  {
3304  /// InstrumentsTradedOnThePrimaryMarket
3305  InstrumentsTradedOnThePrimaryMarket = 'A',
3306 
3307  /// InstrumentsTradedOnTheSecondaryMarket
3308  InstrumentsTradedOnTheSecondaryMarket = 'B',
3309 
3310  /// InstrumentsTradedOnTheNewMarket
3311  InstrumentsTradedOnTheNewMarket = 'C',
3312 
3313  /// NonRegulatedMarketInstrumentsTradedOnTheFreeMarket
3314  NonRegulatedMarketInstrumentsTradedOnTheFreeMarket = 'D',
3315 
3316  /// NonRegulatedMarketAlternext
3317  NonRegulatedMarketAlternext = 'E',
3318 
3319  /// NonListed
3320  NonListed = 'F',
3321 
3322  /// RegulatedMarketNonEquities
3323  RegulatedMarketNonEquities = 'G',
3324 
3325  /// RegulatedMarketEquitiesSegmentA
3326  RegulatedMarketEquitiesSegmentA = 'H',
3327 
3328  /// RegulatedMarketEquitiesSegmentB
3329  RegulatedMarketEquitiesSegmentB = 'I',
3330 
3331  /// RegulatedMarketEquitiesSegmentC
3332  RegulatedMarketEquitiesSegmentC = 'J',
3333 
3334  /// RegulatedMarketAllSecuritiesSpecialSegment
3335  RegulatedMarketAllSecuritiesSpecialSegment = 'K',
3336 
3337  /// RegulatedMarketEquitiesOtherInstruments
3338  RegulatedMarketEquitiesOtherInstruments = 'L',
3339 
3340  /// OPCVMSICOMINonListedFrenchInvestmentFunds
3341  OPCVMSICOMINonListedFrenchInvestmentFunds = 'S',
3342 
3343  /// OffMarket
3344  OffMarket = '6',
3345 
3346  /// GoldCurrenciesAndIndices
3347  GoldCurrenciesAndIndices = '7',
3348 
3349  /// Foreign
3350  Foreign = '9'
3351  };
3352 
3353  /// \return a human-readable presentation.
3355  static
3356  std::string
3357  toString(
3358  Enum);
3359 };
3360 
3361 /// `ExerciseStyle_enum` type.
3363 {
3364  typedef UInt8 Base;
3365 
3366  enum Enum
3367  {
3368  /// European
3369  European = 0,
3370 
3371  /// American
3372  American = 1,
3373 
3374  /// Asian
3375  Asian = 2,
3376 
3377  /// Bermudan
3378  Bermudan = 3,
3379 
3380  /// Other
3381  Other = 4,
3382 
3383  /// Periodic
3384  Periodic = 5
3385  };
3386 
3387  /// \return a human-readable presentation.
3389  static
3390  std::string
3391  toString(
3392  Enum);
3393 };
3394 
3395 /// `ContractTradingType_enum` type.
3397 {
3398  typedef UInt8 Base;
3399 
3400  enum Enum
3401  {
3402  /// NotApplicable
3403  NotApplicable = 0,
3404 
3405  /// TradedAsAnOutright
3406  TradedAsAnOutright = 1,
3407 
3408  /// NotTradedButListedInContractDataTradersMaySubscribeTo
3409  NotTradedButListedInContractDataTradersMaySubscribeTo = 2,
3410 
3411  /// TradedAsASimpleIntercommoditySpread
3412  TradedAsASimpleIntercommoditySpread = 3,
3413 
3414  /// TradedAsAnIntercommoditySpread
3415  TradedAsAnIntercommoditySpread = 4
3416  };
3417 
3418  /// \return a human-readable presentation.
3420  static
3421  std::string
3422  toString(
3423  Enum);
3424 };
3425 
3426 /// `OpenedClosedFund_enum` type.
3428 {
3429  typedef Char Base;
3430 
3431  enum Enum
3432  {
3433  /// Open
3434  Open = 'O',
3435 
3436  /// Closed
3437  Closed = 'C'
3438  };
3439 
3440  /// \return a human-readable presentation.
3442  static
3443  std::string
3444  toString(
3445  Enum);
3446 };
3447 
3448 /// `GrossofCDSCIndicator_enum` type.
3450 {
3451  typedef Char Base;
3452 
3453  enum Enum
3454  {
3455  /// No
3456  No = 'N',
3457 
3458  /// Yes
3459  Yes = 'Y'
3460  };
3461 
3462  /// \return a human-readable presentation.
3464  static
3465  std::string
3466  toString(
3467  Enum);
3468 };
3469 
3470 /// `PaymentFrequency_enum` type.
3472 {
3473  typedef UInt8 Base;
3474 
3475  enum Enum
3476  {
3477  /// Annual
3478  Annual = 1,
3479 
3480  /// SemiAnnual
3481  SemiAnnual = 2,
3482 
3483  /// Quarterly
3484  Quarterly = 3,
3485 
3486  /// Monthly
3487  Monthly = 4,
3488 
3489  /// BiMonthly
3490  BiMonthly = 5,
3491 
3492  /// Daily
3493  Daily = 6,
3494 
3495  /// MigrationNA
3496  MigrationNA = 7,
3497 
3498  /// Other
3499  Other = 8,
3500 
3501  /// NoCoupon
3502  NoCoupon = 9,
3503 
3504  /// AtMaturity
3505  AtMaturity = 10,
3506 
3507  /// Triannual
3508  Triannual = 11,
3509 
3510  /// Capitalization
3511  Capitalization = 12,
3512 
3513  /// IMMDates
3514  IMMDates = 13,
3515 
3516  /// Bimestrial
3517  Bimestrial = 14,
3518 
3519  /// Weekly
3520  Weekly = 15
3521  };
3522 
3523  /// \return a human-readable presentation.
3525  static
3526  std::string
3527  toString(
3528  Enum);
3529 };
3530 
3531 /// `SecurityCondition_enum` type.
3533 {
3534  typedef Char Base;
3535 
3536  enum Enum
3537  {
3538  /// Normal
3539  Normal = 'O',
3540 
3541  /// ExDividend
3542  ExDividend = 'D',
3543 
3544  /// ExCap
3545  ExCap = 'C',
3546 
3547  /// ExRights
3548  ExRights = 'R',
3549 
3550  /// ExEntitlement
3551  ExEntitlement = 'E',
3552 
3553  /// DealingsTemporarilySuspended
3554  DealingsTemporarilySuspended = 'S',
3555 
3556  /// NotListed
3557  NotListed = 'N'
3558  };
3559 
3560  /// \return a human-readable presentation.
3562  static
3563  std::string
3564  toString(
3565  Enum);
3566 };
3567 
3568 /// `TaxDescriptionAttachingtoaDividend_enum` type.
3570 {
3571  typedef Char Base;
3572 
3573  enum Enum
3574  {
3575  /// DeducedAtSource
3576  DeducedAtSource = 'D'
3577  };
3578 
3579  /// \return a human-readable presentation.
3581  static
3582  std::string
3583  toString(
3584  Enum);
3585 };
3586 
3587 /// `TradingPolicy_enum` type.
3589 {
3590  typedef UInt8 Base;
3591 
3592  enum Enum
3593  {
3594  /// PriceExplicitTime
3595  PriceExplicitTime = 1,
3596 
3597  /// PriceProRata
3598  PriceProRata = 2
3599  };
3600 
3601  /// \return a human-readable presentation.
3603  static
3604  std::string
3605  toString(
3606  Enum);
3607 };
3608 
3609 /// `DerivativesMarketModel_enum` type.
3611 {
3612  typedef UInt8 Base;
3613 
3614  enum Enum
3615  {
3616  /// NoSyntheticQuote
3617  NoSyntheticQuote = 0,
3618 
3619  /// SpontaneousImpliedMatching
3620  SpontaneousImpliedMatching = 1,
3621 
3622  /// EventDrivenImpliedMatching
3623  EventDrivenImpliedMatching = 2
3624  };
3625 
3626  /// \return a human-readable presentation.
3628  static
3629  std::string
3630  toString(
3631  Enum);
3632 };
3633 
3634 /// `DerivativesInstrumentType_enum` type.
3636 {
3637  typedef UInt8 Base;
3638 
3639  enum Enum
3640  {
3641  /// CallOption
3642  CallOption = 0,
3643 
3644  /// PutOption
3645  PutOption = 1,
3646 
3647  /// Strategy
3648  Strategy = 2,
3649 
3650  /// IndividualFuture
3651  IndividualFuture = 3,
3652 
3653  /// Underlying
3654  Underlying = 4
3655  };
3656 
3657  /// \return a human-readable presentation.
3659  static
3660  std::string
3661  toString(
3662  Enum);
3663 };
3664 
3665 /// `Anonymous_enum` type.
3667 {
3668  typedef UInt8 Base;
3669 
3670  enum Enum
3671  {
3672  /// No
3673  No = 0,
3674 
3675  /// Yes
3676  Yes = 1
3677  };
3678 
3679  /// \return a human-readable presentation.
3681  static
3682  std::string
3683  toString(
3684  Enum);
3685 };
3686 
3687 /// `PriceQualifier_enum` type.
3689 {
3690  typedef UInt8 Base;
3691 
3692  enum Enum
3693  {
3694  /// LastAdjustedClosingPrice
3695  LastAdjustedClosingPrice = 1,
3696 
3697  /// LastTradedPrice
3698  LastTradedPrice = 2,
3699 
3700  /// VolumeWeightedAveragePrice
3701  VolumeWeightedAveragePrice = 3,
3702 
3703  /// ClosingUncrossingPrice
3704  ClosingUncrossingPrice = 4,
3705 
3706  /// ValuationPrice
3707  ValuationPrice = 5,
3708 
3709  /// AverageOfBBO
3710  AverageOfBBO = 6,
3711 
3712  /// AverageOfBestBid
3713  AverageOfBestBid = 7,
3714 
3715  /// UpdatedByMarketOperations
3716  UpdatedByMarketOperations = 8,
3717 
3718  /// ClosingPriceOfReferenceMarket
3719  ClosingPriceOfReferenceMarket = 9
3720  };
3721 
3722  /// \return a human-readable presentation.
3724  static
3725  std::string
3726  toString(
3727  Enum);
3728 };
3729 
3730 /// `MMProtections_set` type.
3732 {
3733 public:
3734  /// Aliases integral type whose bits
3735  /// are used to indicate flag presence.
3736  typedef UInt8 Bits;
3737 
3738  enum
3739  {
3740  Size = sizeof(Bits)
3741  };
3742 
3743 
3744  /// \private
3745  /// Init traits.
3746  struct MemberTraits
3747  {
3748  enum { Count = 1 };
3749 
3750  typedef Bits FirstArgType;
3751  };
3752 
3753  /// Indicates whether Delta bit is set.
3755  bool delta() const
3757  {
3758  return 0 != (bits_ & 0x1);
3759  }
3760 
3761  /// Indicates whether Volume bit is set.
3763  bool volume() const
3765  {
3766  return 0 != (bits_ & 0x2);
3767  }
3768 
3769  /// \return elements as they packed in the set.
3770  Bits bits() const
3772  {
3773  return bits_;
3774  }
3775 
3776  /// Constructs from a value.
3777  explicit
3778  MmProtections(Bits bits = 0)
3780  : bits_(bits)
3781  {
3782  }
3783 
3784  /// \return a human-readable presentation.
3786  std::string
3787  toString() const;
3788 
3789  /// Compares encoded data
3791  bool
3793  const MmProtections& other) const
3795  {
3796  return !(*this == other);
3797  }
3798 
3799  /// Compares encoded data
3801  bool
3803  const MmProtections& other) const
3805  {
3806  return this->bits_ == other.bits_;
3807  }
3808 
3809 private:
3810  Bits bits_;
3811 };
3812 
3813 /// `TradeQualifier_set` type.
3815 {
3816 public:
3817  /// Aliases integral type whose bits
3818  /// are used to indicate flag presence.
3819  typedef UInt8 Bits;
3820 
3821  enum
3822  {
3823  Size = sizeof(Bits)
3824  };
3825 
3826 
3827  /// \private
3828  /// Init traits.
3829  struct MemberTraits
3830  {
3831  enum { Count = 1 };
3832 
3833  typedef Bits FirstArgType;
3834  };
3835 
3836  /// Indicates whether UncrossingTrade bit is set.
3838  bool uncrossingTrade() const
3840  {
3841  return 0 != (bits_ & 0x1);
3842  }
3843 
3844  /// Indicates whether FirstTradePrice bit is set.
3846  bool firstTradePrice() const
3848  {
3849  return 0 != (bits_ & 0x2);
3850  }
3851 
3852  /// Indicates whether PassiveOrder bit is set.
3854  bool passiveOrder() const
3856  {
3857  return 0 != (bits_ & 0x4);
3858  }
3859 
3860  /// Indicates whether AggressiveOrder bit is set.
3862  bool aggressiveOrder() const
3864  {
3865  return 0 != (bits_ & 0x8);
3866  }
3867 
3868  /// Indicates whether TradeCreationByMarketOperations bit is set.
3872  {
3873  return 0 != (bits_ & 0x10);
3874  }
3875 
3876  /// Indicates whether NAVTradeExpressedInBps bit is set.
3880  {
3881  return 0 != (bits_ & 0x20);
3882  }
3883 
3884  /// Indicates whether NAVTradeExpressedInPriceCurrency bit is set.
3888  {
3889  return 0 != (bits_ & 0x40);
3890  }
3891 
3892  /// Indicates whether DeferredPublication bit is set.
3894  bool deferredPublication() const
3896  {
3897  return 0 != (bits_ & 0x80);
3898  }
3899 
3900  /// \return elements as they packed in the set.
3901  Bits bits() const
3903  {
3904  return bits_;
3905  }
3906 
3907  /// Constructs from a value.
3908  explicit
3909  TradeQualifier(Bits bits = 0)
3911  : bits_(bits)
3912  {
3913  }
3914 
3915  /// \return a human-readable presentation.
3917  std::string
3918  toString() const;
3919 
3920  /// Compares encoded data
3922  bool
3924  const TradeQualifier& other) const
3926  {
3927  return !(*this == other);
3928  }
3929 
3930  /// Compares encoded data
3932  bool
3934  const TradeQualifier& other) const
3936  {
3937  return this->bits_ == other.bits_;
3938  }
3939 
3940 private:
3941  Bits bits_;
3942 };
3943 
3944 /// `PhaseQualifier_set` type.
3946 {
3947 public:
3948  /// Aliases integral type whose bits
3949  /// are used to indicate flag presence.
3950  typedef UInt16 Bits;
3951 
3952  enum
3953  {
3954  Size = sizeof(Bits)
3955  };
3956 
3957 
3958  /// \private
3959  /// Init traits.
3960  struct MemberTraits
3961  {
3962  enum { Count = 1 };
3963 
3964  typedef Bits FirstArgType;
3965  };
3966 
3967  /// Indicates whether NoQualifier bit is set.
3969  bool qualifier() const
3971  {
3972  return 0 != (bits_ & 0x1);
3973  }
3974 
3975  /// Indicates whether CallBBOOnly bit is set.
3977  bool callBBOOnly() const
3979  {
3980  return 0 != (bits_ & 0x2);
3981  }
3982 
3983  /// Indicates whether TradingAtLast bit is set.
3985  bool tradingAtLast() const
3987  {
3988  return 0 != (bits_ & 0x4);
3989  }
3990 
3991  /// Indicates whether RandomUncrossing bit is set.
3993  bool randomUncrossing() const
3995  {
3996  return 0 != (bits_ & 0x8);
3997  }
3998 
3999  /// Indicates whether Suspended bit is set.
4001  bool suspended() const
4003  {
4004  return 0 != (bits_ & 0x10);
4005  }
4006 
4007  /// Indicates whether WholesaleAllowed bit is set.
4009  bool wholesaleAllowed() const
4011  {
4012  return 0 != (bits_ & 0x20);
4013  }
4014 
4015  /// Indicates whether StressedMarketConditions bit is set.
4019  {
4020  return 0 != (bits_ & 0x40);
4021  }
4022 
4023  /// Indicates whether ExceptionalMarketConditions bit is set.
4027  {
4028  return 0 != (bits_ & 0x80);
4029  }
4030 
4031  /// Indicates whether QuotingPeriod bit is set.
4033  bool quotingPeriod() const
4035  {
4036  return 0 != (bits_ & 0x200);
4037  }
4038 
4039  /// Indicates whether ExecutionPreventionAcrossAllFirms bit is set.
4043  {
4044  return 0 != (bits_ & 0x400);
4045  }
4046 
4047  /// \return elements as they packed in the set.
4048  Bits bits() const
4050  {
4051  return bits_;
4052  }
4053 
4054  /// Constructs from a value.
4055  explicit
4056  PhaseQualifier(Bits bits = 0)
4058  : bits_(bits)
4059  {
4060  }
4061 
4062  /// \return a human-readable presentation.
4064  std::string
4065  toString() const;
4066 
4067  /// Compares encoded data
4069  bool
4071  const PhaseQualifier& other) const
4073  {
4074  return !(*this == other);
4075  }
4076 
4077  /// Compares encoded data
4079  bool
4081  const PhaseQualifier& other) const
4083  {
4084  return this->bits_ == other.bits_;
4085  }
4086 
4087 private:
4088  Bits bits_;
4089 };
4090 
4091 /// `StrategyAuthorized_set` type.
4093 {
4094 public:
4095  /// Aliases integral type whose bits
4096  /// are used to indicate flag presence.
4097  typedef UInt64 Bits;
4098 
4099  enum
4100  {
4101  Size = sizeof(Bits)
4102  };
4103 
4104 
4105  /// \private
4106  /// Init traits.
4107  struct MemberTraits
4108  {
4109  enum { Count = 1 };
4110 
4111  typedef Bits FirstArgType;
4112  };
4113 
4114  /// Indicates whether JellyRoll bit is set.
4116  bool jellyRoll() const
4118  {
4119  return 0 != (bits_ & 0x1);
4120  }
4121 
4122  /// Indicates whether Butterfly bit is set.
4124  bool butterfly() const
4126  {
4127  return 0 != (bits_ & 0x2);
4128  }
4129 
4130  /// Indicates whether CallOrPutCabinet bit is set.
4132  bool callOrPutCabinet() const
4134  {
4135  return 0 != (bits_ & 0x4);
4136  }
4137 
4138  /// Indicates whether Spread bit is set.
4140  bool spread() const
4142  {
4143  return 0 != (bits_ & 0x8);
4144  }
4145 
4146  /// Indicates whether CalendarSpread bit is set.
4148  bool calendarSpread() const
4150  {
4151  return 0 != (bits_ & 0x10);
4152  }
4153 
4154  /// Indicates whether DiagonalCalendarSpread bit is set.
4158  {
4159  return 0 != (bits_ & 0x20);
4160  }
4161 
4162  /// Indicates whether Guts bit is set.
4164  bool guts() const
4166  {
4167  return 0 != (bits_ & 0x40);
4168  }
4169 
4170  /// Indicates whether TwoByOneRatioSpread bit is set.
4172  bool twoByOneRatioSpread() const
4174  {
4175  return 0 != (bits_ & 0x80);
4176  }
4177 
4178  /// Indicates whether IronButterfly bit is set.
4180  bool ironButterfly() const
4182  {
4183  return 0 != (bits_ & 0x100);
4184  }
4185 
4186  /// Indicates whether Combo bit is set.
4188  bool combo() const
4190  {
4191  return 0 != (bits_ & 0x200);
4192  }
4193 
4194  /// Indicates whether Strangle bit is set.
4196  bool strangle() const
4198  {
4199  return 0 != (bits_ & 0x400);
4200  }
4201 
4202  /// Indicates whether Ladder bit is set.
4204  bool ladder() const
4206  {
4207  return 0 != (bits_ & 0x800);
4208  }
4209 
4210  /// Indicates whether Strip bit is set.
4212  bool strip() const
4214  {
4215  return 0 != (bits_ & 0x1000);
4216  }
4217 
4218  /// Indicates whether StraddleCalendarSpread bit is set.
4222  {
4223  return 0 != (bits_ & 0x2000);
4224  }
4225 
4226  /// Indicates whether Pack bit is set.
4228  bool pack() const
4230  {
4231  return 0 != (bits_ & 0x4000);
4232  }
4233 
4234  /// Indicates whether DiagonalStraddleCalendarSpread bit is set.
4238  {
4239  return 0 != (bits_ & 0x8000);
4240  }
4241 
4242  /// Indicates whether SimpleInterCommoditySpread bit is set.
4246  {
4247  return 0 != (bits_ & 0x10000);
4248  }
4249 
4250  /// Indicates whether ConversionReversal bit is set.
4252  bool conversionReversal() const
4254  {
4255  return 0 != (bits_ & 0x20000);
4256  }
4257 
4258  /// Indicates whether Straddle bit is set.
4260  bool straddle() const
4262  {
4263  return 0 != (bits_ & 0x40000);
4264  }
4265 
4266  /// Indicates whether VolatilityTrade bit is set.
4268  bool volatilityTrade() const
4270  {
4271  return 0 != (bits_ & 0x80000);
4272  }
4273 
4274  /// Indicates whether Condor bit is set.
4276  bool condor() const
4278  {
4279  return 0 != (bits_ & 0x100000);
4280  }
4281 
4282  /// Indicates whether Box bit is set.
4284  bool box() const
4286  {
4287  return 0 != (bits_ & 0x200000);
4288  }
4289 
4290  /// Indicates whether Bundle bit is set.
4292  bool bundle() const
4294  {
4295  return 0 != (bits_ & 0x400000);
4296  }
4297 
4298  /// Indicates whether ReducedTickSpread bit is set.
4300  bool reducedTickSpread() const
4302  {
4303  return 0 != (bits_ & 0x800000);
4304  }
4305 
4306  /// Indicates whether LadderVersusUnderlying bit is set.
4310  {
4311  return 0 != (bits_ & 0x1000000);
4312  }
4313 
4314  /// Indicates whether ButterflyVersusUnderlying bit is set.
4318  {
4319  return 0 != (bits_ & 0x2000000);
4320  }
4321 
4322  /// Indicates whether CallSpreadVersusPutVersusUnderlying bit is set.
4326  {
4327  return 0 != (bits_ & 0x4000000);
4328  }
4329 
4330  /// Indicates whether CallOrPutSpreadVersusUnderlying bit is set.
4334  {
4335  return 0 != (bits_ & 0x8000000);
4336  }
4337 
4338  /// Indicates whether CallOrPutCalendarSpreadVersusUnderlying bit is set.
4342  {
4343  return 0 != (bits_ & 0x10000000);
4344  }
4345 
4346  /// Indicates whether CallPutDiagonalCalendarSpreadVersusUnderlying bit is set.
4350  {
4351  return 0 != (bits_ & 0x20000000);
4352  }
4353 
4354  /// Indicates whether GutsVersusUnderlying bit is set.
4358  {
4359  return 0 != (bits_ & 0x40000000);
4360  }
4361 
4362  /// Indicates whether TwoByOneCallOrPutRatioSpreadVersusUnderlying bit is set.
4366  {
4367  return 0 != (bits_ & 0x80000000);
4368  }
4369 
4370  /// Indicates whether IronButterflyVersusUnderlying bit is set.
4374  {
4375  return 0 != (bits_ & 0x100000000);
4376  }
4377 
4378  /// Indicates whether ComboVersusUnderlying bit is set.
4382  {
4383  return 0 != (bits_ & 0x200000000);
4384  }
4385 
4386  /// Indicates whether StrangleVersusUnderlying bit is set.
4390  {
4391  return 0 != (bits_ & 0x400000000);
4392  }
4393 
4394  /// Indicates whether ExchangeForPhysical bit is set.
4396  bool exchangeForPhysical() const
4398  {
4399  return 0 != (bits_ & 0x800000000);
4400  }
4401 
4402  /// Indicates whether StraddleCalendarSpreadVersusUnderlying bit is set.
4406  {
4407  return 0 != (bits_ & 0x1000000000);
4408  }
4409 
4410  /// Indicates whether PutSpreadVersusCallVersusUnderlying bit is set.
4414  {
4415  return 0 != (bits_ & 0x2000000000);
4416  }
4417 
4418  /// Indicates whether DiagonalStraddleCalendarSpreadVersusUnderlying bit is set.
4422  {
4423  return 0 != (bits_ & 0x4000000000);
4424  }
4425 
4426  /// Indicates whether Synthetic bit is set.
4428  bool synthetic() const
4430  {
4431  return 0 != (bits_ & 0x8000000000);
4432  }
4433 
4434  /// Indicates whether StraddleVersusUnderlying bit is set.
4438  {
4439  return 0 != (bits_ & 0x10000000000);
4440  }
4441 
4442  /// Indicates whether CondorVersusUnderlying bit is set.
4446  {
4447  return 0 != (bits_ & 0x20000000000);
4448  }
4449 
4450  /// Indicates whether BuyWrite bit is set.
4452  bool buyWrite() const
4454  {
4455  return 0 != (bits_ & 0x40000000000);
4456  }
4457 
4458  /// Indicates whether IronCondorVersusUnderlying bit is set.
4462  {
4463  return 0 != (bits_ & 0x80000000000);
4464  }
4465 
4466  /// Indicates whether IronCondor bit is set.
4468  bool ironCondor() const
4470  {
4471  return 0 != (bits_ & 0x100000000000);
4472  }
4473 
4474  /// Indicates whether CallSpreadVersusSellAPut bit is set.
4478  {
4479  return 0 != (bits_ & 0x200000000000);
4480  }
4481 
4482  /// Indicates whether PutSpreadVersusSellACall bit is set.
4486  {
4487  return 0 != (bits_ & 0x400000000000);
4488  }
4489 
4490  /// Indicates whether PutStraddleVersusSellACallOrAPut bit is set.
4494  {
4495  return 0 != (bits_ & 0x800000000000);
4496  }
4497 
4498  /// Indicates whether ICSOneSidedCombinationSameExpiry bit is set.
4502  {
4503  return 0 != (bits_ & 0x1000000000000);
4504  }
4505 
4506  /// Indicates whether ICSTwoSidedCombinationSameExpiry bit is set.
4510  {
4511  return 0 != (bits_ & 0x2000000000000);
4512  }
4513 
4514  /// \return elements as they packed in the set.
4515  Bits bits() const
4517  {
4518  return bits_;
4519  }
4520 
4521  /// Constructs from a value.
4522  explicit
4523  StrategyAuthorized(Bits bits = 0)
4525  : bits_(bits)
4526  {
4527  }
4528 
4529  /// \return a human-readable presentation.
4531  std::string
4532  toString() const;
4533 
4534  /// Compares encoded data
4536  bool
4538  const StrategyAuthorized& other) const
4540  {
4541  return !(*this == other);
4542  }
4543 
4544  /// Compares encoded data
4546  bool
4548  const StrategyAuthorized& other) const
4550  {
4551  return this->bits_ == other.bits_;
4552  }
4553 
4554 private:
4555  Bits bits_;
4556 };
4557 
4558 /// `OrderTypeRules_set` type.
4560 {
4561 public:
4562  /// Aliases integral type whose bits
4563  /// are used to indicate flag presence.
4564  typedef UInt16 Bits;
4565 
4566  enum
4567  {
4568  Size = sizeof(Bits)
4569  };
4570 
4571 
4572  /// \private
4573  /// Init traits.
4574  struct MemberTraits
4575  {
4576  enum { Count = 1 };
4577 
4578  typedef Bits FirstArgType;
4579  };
4580 
4581  /// Indicates whether Market bit is set.
4583  bool market() const
4585  {
4586  return 0 != (bits_ & 0x1);
4587  }
4588 
4589  /// Indicates whether Limit bit is set.
4591  bool limit() const
4593  {
4594  return 0 != (bits_ & 0x2);
4595  }
4596 
4597  /// Indicates whether StopStopLoss bit is set.
4599  bool stopStopLoss() const
4601  {
4602  return 0 != (bits_ & 0x4);
4603  }
4604 
4605  /// Indicates whether StopLimit bit is set.
4607  bool stopLimit() const
4609  {
4610  return 0 != (bits_ & 0x8);
4611  }
4612 
4613  /// Indicates whether MarketOnOpenMOO bit is set.
4615  bool marketOnOpenMOO() const
4617  {
4618  return 0 != (bits_ & 0x10);
4619  }
4620 
4621  /// Indicates whether TradeAtSettlement bit is set.
4623  bool tradeAtSettlement() const
4625  {
4626  return 0 != (bits_ & 0x20);
4627  }
4628 
4629  /// \return elements as they packed in the set.
4630  Bits bits() const
4632  {
4633  return bits_;
4634  }
4635 
4636  /// Constructs from a value.
4637  explicit
4638  OrderTypeRules(Bits bits = 0)
4640  : bits_(bits)
4641  {
4642  }
4643 
4644  /// \return a human-readable presentation.
4646  std::string
4647  toString() const;
4648 
4649  /// Compares encoded data
4651  bool
4653  const OrderTypeRules& other) const
4655  {
4656  return !(*this == other);
4657  }
4658 
4659  /// Compares encoded data
4661  bool
4663  const OrderTypeRules& other) const
4665  {
4666  return this->bits_ == other.bits_;
4667  }
4668 
4669 private:
4670  Bits bits_;
4671 };
4672 
4673 
4674 /// Null value for an optional UnsignedChar field.
4675 typedef
4678 
4679 
4680 /// Null value for an optional Int8 field.
4681 typedef
4682 IntegralConstant<Int8, -128>
4684 
4685 
4686 /// Null value for an optional Uint16 field.
4687 typedef
4690 
4691 
4692 /// Null value for an optional Uint32 field.
4693 typedef
4696 
4697 
4698 /// Null value for an optional Uint64 field.
4699 typedef
4702 
4703 
4704 /// Null value for an optional Int32 field.
4705 typedef
4706 IntegralConstant<Int32, -2147483647-1>
4708 
4709 
4710 /// Null value for an optional Int64 field.
4711 typedef
4712 IntegralConstant<Int64, -9223372036854775807LL-1>
4714 
4715 
4716 /// Null value for an optional Time field.
4717 typedef
4720 
4721 
4722 
4723 typedef
4726 
4727 typedef
4728 IntegralConstant<Char, -128>
4730 
4731 typedef
4734 
IntegralConstant< UInt64, 18446744073709551615ULL > NullUInt64
Definition: Fields.h:4733
bool gutsVersusUnderlying() const noexcept
Indicates whether GutsVersusUnderlying bit is set.
Definition: Fields.h:4356
bool synthetic() const noexcept
Indicates whether Synthetic bit is set.
Definition: Fields.h:4428
Int64 Int64
Type alias for the Int64_t.
Definition: Fields.h:53
bool operator==(const OrderTypeRules &other) const noexcept
Compares encoded data.
Definition: Fields.h:4662
bool bundle() const noexcept
Indicates whether Bundle bit is set.
Definition: Fields.h:4292
bool uncrossingTrade() const noexcept
Indicates whether UncrossingTrade bit is set.
Definition: Fields.h:3838
bool operator!=(const MmProtections &other) const noexcept
Compares encoded data.
Definition: Fields.h:3792
IntegralConstant< Char,-128 > NullChar
Definition: Fields.h:4729
Char Char16[16]
Type alias for the Char16.
Definition: Fields.h:113
bool strip() const noexcept
Indicates whether Strip bit is set.
Definition: Fields.h:4212
bool callSpreadVersusSellAPut() const noexcept
Indicates whether CallSpreadVersusSellAPut bit is set.
Definition: Fields.h:4476
Char Char27[27]
Type alias for the Char27.
Definition: Fields.h:133
Char Char100[100]
Type alias for the Char100.
Definition: Fields.h:157
bool strangle() const noexcept
Indicates whether Strangle bit is set.
Definition: Fields.h:4196
bool callOrPutCabinet() const noexcept
Indicates whether CallOrPutCabinet bit is set.
Definition: Fields.h:4132
#define ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_END
Definition: ABI.h:151
bool volume() const noexcept
Indicates whether Volume bit is set.
Definition: Fields.h:3763
Int32 Int32
Type alias for the Int32_t.
Definition: Fields.h:49
Char Char25[25]
Type alias for the Char25.
Definition: Fields.h:129
UInt16 Bits
Aliases integral type whose bits are used to indicate flag presence.
Definition: Fields.h:3950
bool operator!=(const StrategyAuthorized &other) const noexcept
Compares encoded data.
Definition: Fields.h:4537
IntegralConstant< UInt8, 255 > NullUnsignedChar
Null value for an optional UnsignedChar field.
Definition: Fields.h:4677
bool ladderVersusUnderlying() const noexcept
Indicates whether LadderVersusUnderlying bit is set.
Definition: Fields.h:4308
IntegralConstant< UInt16, 65535 > NullUint16
Null value for an optional Uint16 field.
Definition: Fields.h:4689
bool simpleInterCommoditySpread() const noexcept
Indicates whether SimpleInterCommoditySpread bit is set.
Definition: Fields.h:4244
bool tradingAtLast() const noexcept
Indicates whether TradingAtLast bit is set.
Definition: Fields.h:3985
bool box() const noexcept
Indicates whether Box bit is set.
Definition: Fields.h:4284
IntegralConstant< UInt32, 4294967295 > NullUint32
Null value for an optional Uint32 field.
Definition: Fields.h:4695
IntegralConstant< Int8,-128 > NullInt8
Null value for an optional Int8 field.
Definition: Fields.h:4683
bool wholesaleAllowed() const noexcept
Indicates whether WholesaleAllowed bit is set.
Definition: Fields.h:4009
bool condor() const noexcept
Indicates whether Condor bit is set.
Definition: Fields.h:4276
bool conversionReversal() const noexcept
Indicates whether ConversionReversal bit is set.
Definition: Fields.h:4252
bool tradeCreationByMarketOperations() const noexcept
Indicates whether TradeCreationByMarketOperations bit is set.
Definition: Fields.h:3870
Char Char24[24]
Type alias for the Char24.
Definition: Fields.h:125
Char Char7[7]
Type alias for the Char7.
Definition: Fields.h:85
Char Char102[102]
Type alias for the Char102.
Definition: Fields.h:161
#define ONIXS_EURONEXT_OPTIQMDG_NOTHROW
Definition: Compiler.h:186
MmProtections(Bits bits=0) noexcept
Constructs from a value.
Definition: Fields.h:3778
bool operator==(const PhaseQualifier &other) const noexcept
Compares encoded data.
Definition: Fields.h:4080
bool combo() const noexcept
Indicates whether Combo bit is set.
Definition: Fields.h:4188
bool twoByOneRatioSpread() const noexcept
Indicates whether TwoByOneRatioSpread bit is set.
Definition: Fields.h:4172
bool stopStopLoss() const noexcept
Indicates whether StopStopLoss bit is set.
Definition: Fields.h:4599
UInt64 Bits
Aliases integral type whose bits are used to indicate flag presence.
Definition: Fields.h:4097
Char Char250[250]
Type alias for the Char250.
Definition: Fields.h:165
#define ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
Definition: ABI.h:94
bool exceptionalMarketConditions() const noexcept
Indicates whether ExceptionalMarketConditions bit is set.
Definition: Fields.h:4025
Char Char3[3]
Type alias for the Char3.
Definition: Fields.h:69
bool straddleVersusUnderlying() const noexcept
Indicates whether StraddleVersusUnderlying bit is set.
Definition: Fields.h:4436
bool putSpreadVersusSellACall() const noexcept
Indicates whether PutSpreadVersusSellACall bit is set.
Definition: Fields.h:4484
UInt16 Bits
Aliases integral type whose bits are used to indicate flag presence.
Definition: Fields.h:4564
Char Char12[12]
Type alias for the Char12.
Definition: Fields.h:101
bool executionPreventionAcrossAllFirms() const noexcept
Indicates whether ExecutionPreventionAcrossAllFirms bit is set.
Definition: Fields.h:4041
bool callPutDiagonalCalendarSpreadVersusUnderlying() const noexcept
Indicates whether CallPutDiagonalCalendarSpreadVersusUnderlying bit is set.
Definition: Fields.h:4348
bool calendarSpread() const noexcept
Indicates whether CalendarSpread bit is set.
Definition: Fields.h:4148
TradeQualifier(Bits bits=0) noexcept
Constructs from a value.
Definition: Fields.h:3909
bool twoByOneCallOrPutRatioSpreadVersusUnderlying() const noexcept
Indicates whether TwoByOneCallOrPutRatioSpreadVersusUnderlying bit is set.
Definition: Fields.h:4364
bool operator!=(const OrderTypeRules &other) const noexcept
Compares encoded data.
Definition: Fields.h:4652
Char Char50[50]
Type alias for the Char50.
Definition: Fields.h:145
UInt8 Bits
Aliases integral type whose bits are used to indicate flag presence.
Definition: Fields.h:3736
#define ONIXS_EURONEXT_OPTIQMDG_NODISCARD
Definition: Compiler.h:195
bool butterflyVersusUnderlying() const noexcept
Indicates whether ButterflyVersusUnderlying bit is set.
Definition: Fields.h:4316
Char Char1
Type alias for the Char1.
Definition: Fields.h:61
bool ironCondor() const noexcept
Indicates whether IronCondor bit is set.
Definition: Fields.h:4468
bool limit() const noexcept
Indicates whether Limit bit is set.
Definition: Fields.h:4591
bool firstTradePrice() const noexcept
Indicates whether FirstTradePrice bit is set.
Definition: Fields.h:3846
#define ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_BEGIN
Definition: ABI.h:146
bool straddleCalendarSpread() const noexcept
Indicates whether StraddleCalendarSpread bit is set.
Definition: Fields.h:4220
bool pack() const noexcept
Indicates whether Pack bit is set.
Definition: Fields.h:4228
bool exchangeForPhysical() const noexcept
Indicates whether ExchangeForPhysical bit is set.
Definition: Fields.h:4396
Char Char32[32]
Type alias for the Char32.
Definition: Fields.h:141
Char Char20[20]
Type alias for the Char20.
Definition: Fields.h:121
bool suspended() const noexcept
Indicates whether Suspended bit is set.
Definition: Fields.h:4001
Char Char11[11]
Type alias for the Char11.
Definition: Fields.h:97
Char Char15[15]
Type alias for the Char15.
Definition: Fields.h:109
Char Char10[10]
Type alias for the Char10.
Definition: Fields.h:93
Char Char6[6]
Type alias for the Char6.
Definition: Fields.h:81
bool ironButterflyVersusUnderlying() const noexcept
Indicates whether IronButterflyVersusUnderlying bit is set.
Definition: Fields.h:4372
bool reducedTickSpread() const noexcept
Indicates whether ReducedTickSpread bit is set.
Definition: Fields.h:4300
bool putStraddleVersusSellACallOrAPut() const noexcept
Indicates whether PutStraddleVersusSellACallOrAPut bit is set.
Definition: Fields.h:4492
UInt8 UnsignedChar
Type alias for the Unsigned_char.
Definition: Fields.h:29
IntegralConstant< Int64,-9223372036854775807LL-1 > NullInt64
Null value for an optional Int64 field.
Definition: Fields.h:4713
Char Char60[60]
Type alias for the Char60.
Definition: Fields.h:153
bool icsOneSidedCombinationSameExpiry() const noexcept
Indicates whether ICSOneSidedCombinationSameExpiry bit is set.
Definition: Fields.h:4500
bool diagonalCalendarSpread() const noexcept
Indicates whether DiagonalCalendarSpread bit is set.
Definition: Fields.h:4156
bool strangleVersusUnderlying() const noexcept
Indicates whether StrangleVersusUnderlying bit is set.
Definition: Fields.h:4388
bool operator==(const StrategyAuthorized &other) const noexcept
Compares encoded data.
Definition: Fields.h:4547
bool ladder() const noexcept
Indicates whether Ladder bit is set.
Definition: Fields.h:4204
UInt64 Time
Type alias for the Time_t.
Definition: Fields.h:57
bool navTradeExpressedInPriceCurrency() const noexcept
Indicates whether NAVTradeExpressedInPriceCurrency bit is set.
Definition: Fields.h:3886
bool straddleCalendarSpreadVersusUnderlying() const noexcept
Indicates whether StraddleCalendarSpreadVersusUnderlying bit is set.
Definition: Fields.h:4404
bool ironButterfly() const noexcept
Indicates whether IronButterfly bit is set.
Definition: Fields.h:4180
bool qualifier() const noexcept
Indicates whether NoQualifier bit is set.
Definition: Fields.h:3969
PhaseQualifier(Bits bits=0) noexcept
Constructs from a value.
Definition: Fields.h:4056
Char Char4[4]
Type alias for the Char4.
Definition: Fields.h:73
bool deferredPublication() const noexcept
Indicates whether DeferredPublication bit is set.
Definition: Fields.h:3894
Int8 Int8
Type alias for the Int8_t.
Definition: Fields.h:33
bool callBBOOnly() const noexcept
Indicates whether CallBBOOnly bit is set.
Definition: Fields.h:3977
bool operator==(const MmProtections &other) const noexcept
Compares encoded data.
Definition: Fields.h:3802
bool delta() const noexcept
Indicates whether Delta bit is set.
Definition: Fields.h:3755
bool putSpreadVersusCallVersusUnderlying() const noexcept
Indicates whether PutSpreadVersusCallVersusUnderlying bit is set.
Definition: Fields.h:4412
IntegralConstant< UInt64, 18446744073709551615ULL > NullUint64
Null value for an optional Uint64 field.
Definition: Fields.h:4701
UInt64 Uint64
Type alias for the Uint64_t.
Definition: Fields.h:45
bool operator!=(const TradeQualifier &other) const noexcept
Compares encoded data.
Definition: Fields.h:3923
bool quotingPeriod() const noexcept
Indicates whether QuotingPeriod bit is set.
Definition: Fields.h:4033
Message identifiers and length of message root.
Definition: Messages.h:4278
bool randomUncrossing() const noexcept
Indicates whether RandomUncrossing bit is set.
Definition: Fields.h:3993
bool condorVersusUnderlying() const noexcept
Indicates whether CondorVersusUnderlying bit is set.
Definition: Fields.h:4444
UInt32 Uint32
Type alias for the Uint32_t.
Definition: Fields.h:41
bool stopLimit() const noexcept
Indicates whether StopLimit bit is set.
Definition: Fields.h:4607
bool operator!=(const PhaseQualifier &other) const noexcept
Compares encoded data.
Definition: Fields.h:4070
bool stressedMarketConditions() const noexcept
Indicates whether StressedMarketConditions bit is set.
Definition: Fields.h:4017
bool guts() const noexcept
Indicates whether Guts bit is set.
Definition: Fields.h:4164
bool comboVersusUnderlying() const noexcept
Indicates whether ComboVersusUnderlying bit is set.
Definition: Fields.h:4380
IntegralConstant< Int32,-2147483647-1 > NullInt32
Null value for an optional Int32 field.
Definition: Fields.h:4707
bool callSpreadVersusPutVersusUnderlying() const noexcept
Indicates whether CallSpreadVersusPutVersusUnderlying bit is set.
Definition: Fields.h:4324
Char Char13[13]
Type alias for the Char13.
Definition: Fields.h:105
bool marketOnOpenMOO() const noexcept
Indicates whether MarketOnOpenMOO bit is set.
Definition: Fields.h:4615
bool straddle() const noexcept
Indicates whether Straddle bit is set.
Definition: Fields.h:4260
bool passiveOrder() const noexcept
Indicates whether PassiveOrder bit is set.
Definition: Fields.h:3854
bool market() const noexcept
Indicates whether Market bit is set.
Definition: Fields.h:4583
bool volatilityTrade() const noexcept
Indicates whether VolatilityTrade bit is set.
Definition: Fields.h:4268
bool icsTwoSidedCombinationSameExpiry() const noexcept
Indicates whether ICSTwoSidedCombinationSameExpiry bit is set.
Definition: Fields.h:4508
Char Char5[5]
Type alias for the Char5.
Definition: Fields.h:77
bool callOrPutSpreadVersusUnderlying() const noexcept
Indicates whether CallOrPutSpreadVersusUnderlying bit is set.
Definition: Fields.h:4332
bool jellyRoll() const noexcept
Indicates whether JellyRoll bit is set.
Definition: Fields.h:4116
bool ironCondorVersusUnderlying() const noexcept
Indicates whether IronCondorVersusUnderlying bit is set.
Definition: Fields.h:4460
bool callOrPutCalendarSpreadVersusUnderlying() const noexcept
Indicates whether CallOrPutCalendarSpreadVersusUnderlying bit is set.
Definition: Fields.h:4340
IntegralConstant< UInt64, 0ULL > NullTime
Null value for an optional Time field.
Definition: Fields.h:4719
bool operator==(const TradeQualifier &other) const noexcept
Compares encoded data.
Definition: Fields.h:3933
UInt16 Uint16
Type alias for the Uint16_t.
Definition: Fields.h:37
bool aggressiveOrder() const noexcept
Indicates whether AggressiveOrder bit is set.
Definition: Fields.h:3862
bool buyWrite() const noexcept
Indicates whether BuyWrite bit is set.
Definition: Fields.h:4452
UInt8 Bits
Aliases integral type whose bits are used to indicate flag presence.
Definition: Fields.h:3819
OrderTypeRules(Bits bits=0) noexcept
Constructs from a value.
Definition: Fields.h:4638
bool diagonalStraddleCalendarSpreadVersusUnderlying() const noexcept
Indicates whether DiagonalStraddleCalendarSpreadVersusUnderlying bit is set.
Definition: Fields.h:4420
Char Char2[2]
Type alias for the Char2.
Definition: Fields.h:65
bool diagonalStraddleCalendarSpread() const noexcept
Indicates whether DiagonalStraddleCalendarSpread bit is set.
Definition: Fields.h:4236
StrategyAuthorized(Bits bits=0) noexcept
Constructs from a value.
Definition: Fields.h:4523
bool tradeAtSettlement() const noexcept
Indicates whether TradeAtSettlement bit is set.
Definition: Fields.h:4623
Char Char18[18]
Type alias for the Char18.
Definition: Fields.h:117
bool navTradeExpressedInBps() const noexcept
Indicates whether NAVTradeExpressedInBps bit is set.
Definition: Fields.h:3878
Char Char52[52]
Type alias for the Char52.
Definition: Fields.h:149
bool spread() const noexcept
Indicates whether Spread bit is set.
Definition: Fields.h:4140
Char Char30[30]
Type alias for the Char30.
Definition: Fields.h:137
IntegralConstant< UInt8, 255 > NullUInt8
Definition: Fields.h:4725
Char Char8[8]
Type alias for the Char8.
Definition: Fields.h:89
bool butterfly() const noexcept
Indicates whether Butterfly bit is set.
Definition: Fields.h:4124