OnixS C++ Eurex T7 Market and Reference Data (EMDI, MDI, RDI, EOBI) Handlers  14.1.0
API documentation
InstrumentSnapshot.h
Go to the documentation of this file.
1 /*
2 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
3 *
4 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
5 * and international copyright treaties.
6 *
7 * Access to and use of the software is governed by the terms of the applicable OnixS Software
8 * Services Agreement (the Agreement) and Customer end user license agreements granting
9 * a non-assignable, non-transferable and non-exclusive license to use the software
10 * for it's own data processing purposes under the terms defined in the Agreement.
11 *
12 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
13 * of this source code or associated reference material to any other location for further reproduction
14 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
15 *
16 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
17 * the terms of the Agreement is a violation of copyright law.
18 */
19 
20 #pragma once
21 
27 
28 namespace OnixS
29 {
30  namespace Eurex
31  {
32  namespace MarketData
33  {
34 
35  /// Alternate identifier entry.
36  class ONIXS_EUREX_EMDI_API SecurityAlt : GroupInstance
37  {
38  public:
39 
40  /// Alternate instrument identifier.
42  {
43  StringRef val;
44  return get (Tags::SecurityAltID).toStringRef (val) ? val : StringRef();
45  }
46 
47  /// Security alternate id source.
49  {
50  StringRef val;
51  return get (Tags::SecurityAltIDSource).toStringRef (val) ? val : StringRef();
52  }
53 
54  private:
55  friend class TypedGroup<SecurityAlt>;
56 
57  SecurityAlt (const GroupInstance& groupInstance)
58  : GroupInstance (groupInstance)
59  {
60  }
61  };
62 
63  class SecurityAlts : public TypedGroup<SecurityAlt>
64  {
65  private:
66  explicit
67  SecurityAlts (const Group& group)
68  : TypedGroup<SecurityAlt> (group)
69  {
70  }
71 
72  friend class InstrumentSnapshot;
73  };
74 
75  /// Exposes list of available security types.
76  struct ONIXS_EUREX_EMDI_API SecurityType
77  {
78  enum Enum
79  {
80  /// Used to identify absence of value.
81  Undefined = -1,
82 
83  ///
84  Option = 0,
85 
86  ///
87  Future = 1,
88 
89  ///
90  MultiLegInstrument = 2,
91 
92  ///
93  VarianceFutures = 3,
94 
95  ///
96  TotalReturnFutures = 4,
97 
98  ///
99  CommonStock = 5,
100 
101  ///
102  Bond = 6,
103 
104  ///
105  TradeAtReferencePrice = 7,
106 
107  ///
108  ExchangeTradedFund = 8,
109 
110  ///
111  ExchangeTradedCommodity = 9,
112 
113  ///
114  ExchangeTradedNote = 10,
115 
116  ///
118 
119  ///
121 
122  ///
124 
125  ///
127 
128  ///
129  DigitalAssets
130  };
131  };
132 
133  /// Exposes list of Instrument scope operators.
134  struct ONIXS_EUREX_EMDI_API InstrumentScopeOperator
135  {
136  enum Enum
137  {
138  /// Used to identify absence of value.
139  Undefined = -1,
140 
141  ///
142  Include = 0,
143  };
144  };
145 
146  ///
147  struct ONIXS_EUREX_EMDI_API DisplayDayOfWeek
148  {
149  enum Enum
150  {
151  /// Used to identify absence of value.
152  Undefined = -1,
153 
154  Monday = 0,
155  Tuesday = 1,
156  Wednesday = 2,
157  Thursday = 3,
158  Friday = 4,
159  Saturday = 5,
160  Sunday = 6
161  };
162  };
163 
164  ///
165  struct ONIXS_EUREX_EMDI_API PutOrCall
166  {
167  enum Enum
168  {
169  /// Used to identify absence of value.
170  Undefined = -1,
171 
172  ///
173  Put = 0,
174 
175  ///
176  Call = 1
177  };
178  };
179 
180 
181  ///
182  struct ONIXS_EUREX_EMDI_API ExerciseStyle
183  {
184  enum Enum
185  {
186  /// Used to identify absence of value.
187  Undefined = -1,
188 
189  ///
190  European = 0,
191 
192  ///
193  American = 1
194  };
195  };
196 
197  struct ONIXS_EUREX_EMDI_API MultilegModel
198  {
199  enum Enum
200  {
201  /// Used to identify absence of value.
202  Undefined = -1,
203 
204  ///
205  PredefinedMultilegSecurity = 0,
206 
207  ///
208  UserDefinedMultilegSecurity = 1
209  };
210  };
211 
212  ///
213  struct ONIXS_EUREX_EMDI_API ValuationMethod
214  {
215  enum Enum
216  {
217  /// Used to identify absence of value.
218  Undefined = -1,
219 
220  ///
221  PremiumStyle = 0,
222 
223  ///
224  FuturesStyleMarkToMarket = 1
225  };
226  };
227 
228  ///
229  struct ONIXS_EUREX_EMDI_API WarrantType
230  {
231  enum Enum
232  {
233  /// Used to identify absence of value.
234  Undefined = -1,
235 
236  ///
237  Call = 0,
238  ///
240  ///
242  ///
244  ///
245  Other
246  };
247  };
248 
249 
250  struct ONIXS_EUREX_EMDI_API SettlMethod
251  {
252  enum Enum
253  {
254  /// Used to identify absence of value.
255  Undefined = -1,
256 
257  ///
258  Cash = 0,
259 
260  ///
261  Physical = 1
262  };
263  };
264 
265  struct ONIXS_EUREX_EMDI_API SettlSubMethod
266  {
267  enum Enum
268  {
269  /// Used to identify absence of value.
270  Undefined = -1,
271 
272  ///
273  Shares = 0,
274  Derivatives = 1,
275  PaymentVsPayment = 2,
276  Notional = 3,
277  Cascade = 4,
278  Other = 5,
279  Energy = 6
280  };
281  };
282 
283  struct ONIXS_EUREX_EMDI_API InstrumentPartyIDSource
284  {
285  enum Enum
286  {
287  /// Used to identify absence of value.
288  Undefined = -1,
289 
290  ///
291  Proprietary = 0,
292  };
293  };
294 
295  struct ONIXS_EUREX_EMDI_API InstrumentPartyRole
296  {
297  enum Enum
298  {
299  /// Used to identify absence of value.
300  Undefined = -1,
301 
302  ///
303  ClearingOrganization = 0,
304  ///
305  MarketMaker = 1,
306  };
307  };
308 
309  struct ONIXS_EUREX_EMDI_API InstrumentPartyRoleQualifier
310  {
311  enum Enum
312  {
313  /// Used to identify absence of value.
314  Undefined = -1,
315 
316  ///
317  DesignatedSponsor = 0,
318 
319  ///
320  Specialist
321  };
322  };
323 
324  /// Deposit Type
325  struct ONIXS_EUREX_EMDI_API DepositType
326  {
327  enum Enum
328  {
329  /// Used to identify absence of value.
330  Undefined = -1,
331 
332  ///
333  Auslandskassenverein = 0,
334 
335  ///
336  Girosammelverwahrung = 1,
337 
338  ///
339  Streifbandverwahrung = 2,
340 
341  ///
342  Wertpapierrechnung = 3,
343 
344  ///
345  NcsCviaT2S = 4
346  };
347  };
348 
349  /// Accrued interest Calculation Methods
350  struct ONIXS_EUREX_EMDI_API AccruedInterestCalculationMethod
351  {
352  enum Enum
353  {
354  /// Used to identify absence of value.
355  Undefined = -1,
356 
357  ///
358  Basis30360 = 0,
359 
360  ///
362 
363  ///
365 
366  ///
368 
369  ///
371 
372  ///
374 
375  ///
377 
378  ///
380  };
381  };
382 
383  /// Coupon Types
384  struct ONIXS_EUREX_EMDI_API CouponType
385  {
386  enum Enum
387  {
388  /// Used to identify absence of value.
389  Undefined = -1,
390 
391  ///
392  Zero = 0,
393 
394  ///
396 
397  ///
399 
400  ///
402  };
403  };
404 
405  /// Cover Indicator
406  struct ONIXS_EUREX_EMDI_API CoverIndicator
407  {
408  enum Enum
409  {
410  /// Used to identify absence of value.
411  Undefined = -1,
412 
413  ///
414  Intraday = 0,
415 
416  ///
418 
419  ///
421  };
422  };
423 
424  /// Flat Indicators
425  struct ONIXS_EUREX_EMDI_API FlatIndicator
426  {
427  enum Enum
428  {
429  /// Used to identify absence of value.
430  Undefined = -1,
431 
432  ///
433  NoFlat = 0,
434 
435  ///
437 
438  ///
440  };
441  };
442 
443  /// Instrument Party.
444  class ONIXS_EUREX_EMDI_API InstrumentParty : GroupInstance
445  {
446  public:
447 
448  /// Identifies a party associated with an instrument.
449  StringRef id() const
450  {
451  StringRef val;
452  return get (Tags::InstrumentPartyID).toStringRef (val) ? val : StringRef();
453  }
454 
455  ///
457  {
458  return getIntEnumFieldValue<InstrumentPartyIDSource> (*this, Tags::InstrumentPartyIDSource);
459  }
460 
461  ///
463  {
464  return getIntEnumFieldValue<InstrumentPartyRole> (*this, Tags::InstrumentPartyRole);
465  }
466 
467  ///
469  {
470  return getIntEnumFieldValue<InstrumentPartyRoleQualifier> (*this, Tags::InstrumentPartyRoleQualifier);
471  }
472 
473  private:
475 
476  InstrumentParty (const GroupInstance& groupInstance)
477  : GroupInstance (groupInstance)
478  {
479  }
480  };
481 
482  struct ONIXS_EUREX_EMDI_API InstrumentAttributeType
483  {
484  enum Enum
485  {
486  /// Used to identify absence of value.
487  Undefined = -1,
488 
489  ///
490  MinimumReserveOrderQuantity = 0,
491  ///
492  MinimumDisplayQuantity = 1,
493  ///
494  IssuerName = 2,
495  ///
496  IssuerNumber = 3,
497  ///
498  MarketType = 4,
499  ///
500  MarketTypeSupplement = 5,
501  ///
502  ReportingMarket = 6,
503  ///
504  CumExIndicator = 7,
505  ///
506  ProductAssignmentGroup = 8,
507  ///
508  ProductAssignmentGroupDescription = 9,
509  ///
510  PreTradeLISValue = 10,
511  ///
512  VDOMinimumExecutionVolume = 11,
513  ///
514  IlliquidAsDefinedByExchange = 12,
515  ///
516  MarketMakingObligation = 13,
517  ///
518  LiquidAsDefinedByRegulator = 14,
519  ///
520  EligibleForStressedMarketConditions = 15,
521  ///
523  ///
525  ///
527  ///
529  ///
531  ///
533  ///
535  ///
537  ///
539  ///
541  ///
543  ///
545  ///
546  LiquidityClass
547  };
548  };
549 
550  struct ONIXS_EUREX_EMDI_API EventType
551  {
552  enum Enum
553  {
554  /// Used to identify absence of value.
555  Undefined = -1,
556 
557  ///
558  LastEligible = 0,
559 
560  ///
561  FirstEligible = 1,
562 
563  ///
564  CapitalAdjustment = 2,
565 
566  ///
567  DividendPayment = 3
568  };
569  };
570 
571  struct ONIXS_EUREX_EMDI_API InstrumentAuctionType
572  {
573  enum Enum
574  {
575  /// Used to identify absence of value.
576  Undefined = -1,
577 
578  ///
579  Default = 0,
580  ///
581  SingleAuction = 1,
582  ///
583  SpecialAuction = 2
584  };
585  };
586 
587  struct ONIXS_EUREX_EMDI_API PostTradeAnonymityType
588  {
589  enum Enum
590  {
591  /// Used to identify absence of value.
592  Undefined = -1,
593 
594  ///
595  Disabled = 0,
596  ///
597  Enabled = 1,
598  ///
599  CentralCounterparty = 2,
600  };
601  };
602 
603  struct ONIXS_EUREX_EMDI_API PriceType
604  {
605  enum Enum
606  {
607  /// Used to identify absence of value.
608  Undefined = -1,
609 
610  ///
611  Percent = 0,
612  ///
613  Shares = 1,
614  ///
615  Points = 2,
616  };
617  };
618 
619  struct ONIXS_EUREX_EMDI_API ContractIdentificationEligibility
620  {
621  enum Enum
622  {
623  /// Used to identify absence of value.
624  Undefined = -1,
625 
626  ///
628 
629  ///
631 
632  ///
634  };
635  };
636 
637 
638  struct ONIXS_EUREX_EMDI_API ContractCycleType
639  {
640  enum Enum
641  {
642  /// Used to identify absence of value.
643  Undefined = -1,
644 
645  ///
646  Dayly = 0,
647 
648  ///
650 
651  ///
653 
654  ///
656 
657  ///
659 
660  ///
662  };
663  };
664 
665  struct ONIXS_EUREX_EMDI_API ContractCycleSubType
666  {
667  enum Enum
668  {
669  /// Used to identify absence of value.
670  Undefined = -1,
671 
672  ///
673  EndOfMonth = 0,
674  };
675  };
676 
677  struct ONIXS_EUREX_EMDI_API ContractFrequency
678  {
679  enum Enum
680  {
681  /// Used to identify absence of value.
682  Undefined = -1,
683 
684  ///
685  Day = 0,
686 
687  ///
689 
690  ///
692 
693  ///
695 
696  ///
697  EndOfMonth
698 
699  };
700  };
701 
702  struct ONIXS_EUREX_EMDI_API ContractDisplayInstruction
703  {
704  enum Enum
705  {
706  /// Used to identify absence of value.
707  Undefined = -1,
708 
709  ///
710  None = 0,
711 
712  ///
714 
715  ///
717 
718  ///
720 
721  ///
723 
724  ///
726 
727  ///
729 
730  ///
732 
733  ///
735 
736  ///
738 
739  ///
741 
742  ///
743  EndOfMonth
744  };
745  };
746 
747  struct ONIXS_EUREX_EMDI_API DisplaySeason
748  {
749  enum Enum
750  {
751  /// Used to identify absence of value.
752  Undefined = -1,
753 
754  ///
755  Summer = 0,
756 
757  ///
759  };
760  };
761 
762  class InstrumentParties : public TypedGroup<InstrumentParty>
763  {
764  private:
765  explicit
766  InstrumentParties (const Group& group)
768  {
769  }
770 
771  friend class InstrumentSnapshot;
772  };
773 
774  /// Instrument Attribute.
775  class ONIXS_EUREX_EMDI_API InstrumentAttribute : GroupInstance
776  {
777  public:
778 
779  ///
781  {
782  return getIntEnumFieldValue<InstrumentAttributeType> (*this, Tags::InstrAttribType);
783  }
784 
785  ///
786  StringRef value() const
787  {
788  StringRef val;
789  return get (Tags::InstrAttribValue).toStringRef (val) ? val : StringRef();
790  }
791 
792  private:
794 
795  InstrumentAttribute (const GroupInstance& groupInstance)
796  : GroupInstance (groupInstance)
797  {
798  }
799  };
800 
801  class InstrumentAttributes : public TypedGroup<InstrumentAttribute>
802  {
803  private:
804  explicit
805  InstrumentAttributes (const Group& group)
807  {
808  }
809 
810  friend class InstrumentSnapshot;
811  };
812 
813 
814  /// Event.
815  class ONIXS_EUREX_EMDI_API Event : GroupInstance
816  {
817  public:
818  /// Event Type
820  {
821  return getNonZeroIntEnumFieldValue<EventType>(*this, Tags::EventType);
822  }
823 
824  /// Event Date
826  {
827  return getUInt32 (Tags::EventDate);
828  }
829 
830  private:
831  friend class TypedGroup<Event>;
832 
833  Event (const GroupInstance& groupInstance)
834  : GroupInstance (groupInstance)
835  {
836  }
837  };
838 
839  class Events : public TypedGroup<Event>
840  {
841  private:
842  explicit
843  Events (const Group& group)
844  : TypedGroup<Event> (group)
845  {
846  }
847 
848  friend class InstrumentSnapshot;
849  };
850 
851  ///
852  class InstrumentSnapshotLegs : public TypedGroup<InstrumentLeg>
853  {
854  private:
855  explicit
856  InstrumentSnapshotLegs (const Group& group)
857  : TypedGroup<InstrumentLeg> (group)
858  {
859  }
860 
861  friend class InstrumentSnapshot;
862  };
863 
864 
865  /// TradingSessionRules
866  class ONIXS_EUREX_EMDI_API TradingSessionRule : GroupInstance
867  {
868  public:
869 
870  /// Trading Session ID
872  {
873  return 0u;
874  }
875 
876  /// Defines the trading session sub ID.
878  {
879  return getIntEnumFieldValue<TradingSessionSubID> (*this, Tags::TradingSessionSubID);
880  }
881 
882  private:
884 
885  TradingSessionRule (const GroupInstance& groupInstance)
886  : GroupInstance (groupInstance)
887  {
888  }
889  };
890 
891  ///
892  class TradingSessionRules : public TypedGroup<TradingSessionRule>
893  {
894  private:
895  explicit
896  TradingSessionRules (const Group& group)
898  {
899  }
900 
901  friend class InstrumentSnapshot;
902  };
903 
904  /// Instrument snapshot.
905  class ONIXS_EUREX_EMDI_API InstrumentSnapshot : public Message
906  {
907  public:
908  /// Instrument identifier.
910  {
911  return getInt64 (Tags::SecurityID);
912  }
913 
914  /// Entries.
916  {
917  return SecurityAlts ( getGroup (Tags::NoSecurityAltID) );
918  }
919 
920  /// Type of security.
922  {
923  return getIntEnumFieldValue<SecurityType> (*this, Tags::SecurityType);
924  }
925 
926  /// Security Status.
928  {
929  return getIntEnumFieldValue<SecurityStatus> (*this, Tags::SecurityStatus);
930  }
931 
932  /// Security description
933  bool securityDesc(StringRef& desc) const
934  {
935  return get (Tags::SecurityDesc).toStringRef (desc);
936  }
937 
938  /// MIC (ISO 10383), used to identify an instrument of a co-operation partner.
939  bool securityExchange (StringRef& exchange) const
940  {
941  return get (Tags::SecurityExchange).toStringRef (exchange);
942  }
943 
944  /// Type of Market Data update action
946  {
947  return getNonZeroIntEnumFieldValue<InstrumentType>(*this, Tags::ProductComplex);
948  }
949 
950  /// Indicates the type of security using ISO 10962 standard.
951  bool cfiCode(StringRef& desc) const
952  {
953  return get (Tags::CFICode).toStringRef (desc);
954  }
955 
956  /// Display Name
957  bool displayName(StringRef& desc) const
958  {
959  return get(Tags::DisplayName).toStringRef(desc);
960  }
961 
962  /// Defines the granularity which suffice to identify a standard e.g. non - flexible contract uniquely within a product.
964  {
965  return getIntEnumFieldValue<ContractIdentificationEligibility>(*this, Tags::ContractIdentificationEligibility);
966  }
967 
968  /// Defines, if this contract based on its contract generation cycle, is considered primary.
969  bool isPrimary() const
970  {
971  UInt32 value;
972  return get(Tags::IsPrimary).toNumber(value) ? (value == 1) : false;
973  }
974 
975  /// Actual contract start date
976  bool contractDate (UInt32& value)
977  {
978  return get (Tags::ContractDate).toNumber (value);
979  }
980 
981  /// A symbol to describe the type of ContractDate
983  {
984  return get(Tags::ContractDateType).toStringRef(value);
985  }
986 
987  /// Contract start month
988  bool contractMonthYear (UInt32& value)
989  {
990  return get (Tags::ContractMonthYear).toNumber (value);
991  }
992 
993  /// Defines the instrument cycle type
995  {
996  return getIntEnumFieldValue<ContractCycleType>(*this, Tags::ContractCycleType);
997  }
998 
999  /// Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
1001  {
1002  return getIntEnumFieldValue<ContractCycleSubType>(*this, Tags::ContractCycleSubType);
1003  }
1004 
1005  /// Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
1007  {
1008  return getIntEnumFieldValue<ContractFrequency>(*this, Tags::ContractFrequency);
1009  }
1010 
1011  /// Defines the instrument display instruction
1013  {
1014  return getIntEnumFieldValue<ContractDisplayInstruction>(*this, Tags::ContractDisplayInstruction);
1015  }
1016 
1017  /// Display Day
1018  bool displayDay(UInt32& value)
1019  {
1020  return get(Tags::DisplayDay).toNumber(value);
1021  }
1022 
1023  /// Display Relative Day
1025  {
1026  return get(Tags::DisplayRelativeDay).toNumber(value);
1027  }
1028 
1029  /// Display Week
1030  bool displayWeek(UInt32& value)
1031  {
1032  return get(Tags::DisplayWeek).toNumber(value);
1033  }
1034 
1035  /// The day of week of the weekly contract.
1037  {
1038  return getIntEnumFieldValue<DisplayDayOfWeek>(*this, Tags::DisplayDayOfWeek);
1039  }
1040 
1041  /// Display Month
1042  bool displayMonth(UInt32& value)
1043  {
1044  return get(Tags::DisplayMonth).toNumber(value);
1045  }
1046 
1047  /// The Display Quarter denotes the three-month period inside a year.
1048  bool displayQuarter(UInt32& value)
1049  {
1050  return get(Tags::DisplayQuarter).toNumber(value);
1051  }
1052 
1053  /// Defines the instrument display instruction
1055  {
1056  return getIntEnumFieldValue<DisplaySeason>(*this, Tags::DisplaySeason);
1057  }
1058 
1059  /// Display Year
1060  bool displayYear(UInt32& value)
1061  {
1062  return get(Tags::DisplayYear).toNumber(value);
1063  }
1064 
1065  /// Strike Price
1066  bool strikePrice (Decimal& price) const
1067  {
1068  return get (Tags::StrikePrice).toNumber (price);
1069  }
1070 
1071  /// Strike Price Precision
1072  bool strikePricePrecision (UInt32& precision) const
1073  {
1074  return get (Tags::StrikePricePrecision).toNumber (precision);
1075  }
1076 
1077  /// Contract Multiplier
1078  bool contractMultiplier (Decimal& multiplier) const
1079  {
1080  return get (Tags::ContractMultiplier).toNumber (multiplier);
1081  }
1082 
1083  /// Put Or Call
1085  {
1086  return getIntEnumFieldValue<PutOrCall> (*this, Tags::PutOrCall);
1087  }
1088 
1089  /// Version of an option. Version can change as a result of corporate actions or events.
1090  bool optAttribute (UInt32& attribute) const
1091  {
1092  return get (Tags::OptAttribute).toNumber (attribute);
1093  }
1094 
1095  /// Exercise Style
1097  {
1098  return getIntEnumFieldValue<ExerciseStyle> (*this, Tags::ExerciseStyle);
1099  }
1100 
1101  /// Original strike price prior to corporate action, e.g. 5.20.
1102  bool origStrikePrice (Decimal& price) const
1103  {
1104  return get (Tags::OrigStrikePrice).toNumber (price);
1105  }
1106 
1107  /// Contract generation.
1108  bool contractGenerationNumber (UInt32& number) const
1109  {
1110  return get (Tags::ContractGenerationNumber).toNumber (number);
1111  }
1112 
1113  /// Lepo Flag
1115  {
1116  UInt32 value;
1117  return (get (Tags::LowExercisePriceOptionIndicator).toNumber (value) ) ? (value == 1) : false;
1118  }
1119 
1120  /// Traditional or futures margin style.
1122  {
1123  return getIntEnumFieldValue<ValuationMethod> (*this, Tags::ValuationMethod);
1124  }
1125 
1126  ///
1128  {
1129  return getIntEnumFieldValue<SettlMethod> (*this, Tags::SettlMethod);
1130  }
1131 
1132  ///
1134  {
1135  return getIntEnumFieldValue<SettlSubMethod> (*this, Tags::SettlSubMethod);
1136  }
1137 
1138  /// Previous day's settlement price. Converted in trading notation in case of variance futures.
1139  bool priorSettlPrice (Decimal& price) const
1140  {
1141  return get (Tags::PriorSettlPrice).toNumber (price);
1142  }
1143 
1144  /// Previous day’s option delta provided for option instruments only.
1145  bool priceDelta(Decimal& value) const
1146  {
1147  return get(Tags::PriceDelta).toNumber(value);
1148  }
1149 
1150  /// Indicates whether this message is the last in a sequence of messages that together convey a joint list of InstrmtLegGrp.
1152  {
1153  return getIntEnumFieldValue<LastFragment>(*this, Tags::LastFragment);
1154  }
1155 
1156  /// Common integer multiple of the option legs for Option Volatility Strategies.
1157  bool legRatioMultiplier(UInt32& value) const
1158  {
1159  return get(Tags::LegRatioMultiplier).toNumber(value);
1160  }
1161 
1162  /// Legs
1164  {
1165  return InstrumentSnapshotLegs ( getGroup (Tags::NoLegs) );
1166  }
1167 
1168  /// Refers to MarketSegmentID (1300) from the underlying Product Snapshot.
1170  {
1171  return get(Tags::UnderlyingMarketSegmentID).toNumber(val);
1172  }
1173 
1174  /// Refers to SecurityID (48) from the underlying Instrument Snapshot.
1175  bool underlyingSecurityID(Int64& val) const
1176  {
1177  return get(Tags::UnderlyingSecurityID).toNumber(val);
1178  }
1179 
1180 
1181  /// UnitOfMeasure
1182  bool unitOfMeasure(StringRef& val) const
1183  {
1184  return get(Tags::UnitOfMeasure).toStringRef(val);
1185  }
1186 
1187  /// AssetType
1188  bool assetType(UInt32& val) const
1189  {
1190  return get(Tags::AssetType).toNumber(val);
1191  }
1192 
1193  /// AssetSubType
1194  bool assetSubType(UInt32& val) const
1195  {
1196  return get(Tags::AssetSubType).toNumber(val);
1197  }
1198 
1199  /// Transact Time
1200  bool transactTime (UInt64& time) const
1201  {
1202  return get (Tags::TransactTime).toNumber (time);
1203  }
1204 
1205  /// Reference to tick size table identifier from product level message.
1206  bool refTickTableID (UInt32& time) const
1207  {
1208  return get (Tags::RefTickTableID).toNumber (time);
1209  }
1210 
1211  /// Currency as published in ISO 4217.
1212  bool currency (StringRef& value) const
1213  {
1214  return get (Tags::Currency).toStringRef (value);
1215  }
1216 
1217  /// Settlement currency.
1218  bool settlCurrency(StringRef& desc) const
1219  {
1220  return get (Tags::SettlCurrency).toStringRef (desc);
1221  }
1222 
1223  /// DepositType
1225  {
1226  return getIntEnumFieldValue<DepositType>(*this, Tags::DepositType);
1227  }
1228 
1229  /// Issue date of instrument.
1230  bool issueDate(UInt32& date) const
1231  {
1232  return get(Tags::IssueDate).toNumber(date);
1233  }
1234 
1235  ///
1236  bool roundLot(Decimal& value) const
1237  {
1238  return get(Tags::RoundLot).toNumber(value);
1239  }
1240 
1241  /// The minimum tradable unit of a bond.
1242  bool minTradeVol(Decimal& value) const
1243  {
1244  return get(Tags::MinTradeVol).toNumber(value);
1245  }
1246 
1247  /// QuotingStartTime
1248  bool quotingStartTime(StringRef& value) const
1249  {
1250  return get(Tags::QuotingStartTime).toStringRef(value);
1251  }
1252 
1253  /// QuotingEndTime
1254  bool quotingEndTime(StringRef& value) const
1255  {
1256  return get(Tags::QuotingEndTime).toStringRef(value);
1257  }
1258 
1259  /// InstrumentAuctionType
1261  {
1262  return getIntEnumFieldValue<InstrumentAuctionType>(*this, Tags::InstrumentAuctionType);
1263  }
1264 
1265  /// Instrument parties.
1267  {
1268  return InstrumentParties ( getOptionalGroup (Tags::NoInstrumentParties) );
1269  }
1270 
1271  /// Underlying symbol.
1273  {
1274  return getStringRef(Tags::UnderlyingSymbol);
1275  }
1276 
1277  /// Instrument identifier of the leg security.
1278  bool couponRate(Decimal& value) const
1279  {
1280  return get(Tags::CouponRate).toNumber(value);
1281  }
1282 
1283  /// Previous coupon payment date.
1285  {
1286  return get(Tags::PreviousCouponPaymentDate).toNumber(value);
1287  }
1288 
1289  /// Upcoming Coupon payment date.
1290  bool couponPaymentDate(UInt32& value) const
1291  {
1292  return get(Tags::CouponPaymentDate).toNumber(value);
1293  }
1294 
1295  /// Defines the Accrued interest Calculation Method.
1297  {
1298  return getIntEnumFieldValue<AccruedInterestCalculationMethod>(*this, Tags::CouponDayCount);
1299  }
1300 
1301  /// Coupon Type
1303  {
1304  return getIntEnumFieldValue<CouponType>(*this, Tags::CouponType);
1305  }
1306 
1307  /// The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th decimal.
1309  {
1310  return getStringRef(Tags::CountryOfIssue);
1311  }
1312 
1313  /// The Flat Indicator of a bond.
1315  {
1316  return getIntEnumFieldValue<FlatIndicator>(*this, Tags::FlatIndicator);
1317  }
1318 
1319  /// WarrantType
1321  {
1322  return getIntEnumFieldValue<WarrantType>(*this, Tags::WarrantType);
1323  }
1324 
1325  /// CoverIndicator
1327  {
1328  return getIntEnumFieldValue<CoverIndicator>(*this, Tags::CoverIndicator);
1329  }
1330 
1331  /// Reference to Volatility Corridor Table for Opening Auction
1333  {
1334  return get(Tags::VolatilityCorridorOpeningAuction).toNumber(value);
1335  }
1336 
1337  /// Reference to Volatility Corridor Table for Intraday Auction
1339  {
1340  return get(Tags::VolatilityCorridorIntradayAuction).toNumber(value);
1341  }
1342 
1343  /// Reference to Volatility Corridor Table for Closing Auction
1345  {
1346  return get(Tags::VolatilityCorridorClosingAuction).toNumber(value);
1347  }
1348 
1349  /// Reference to Volatility Corridor Table in Continuous
1351  {
1352  return get(Tags::VolatilityCorridorContinuous).toNumber(value);
1353  }
1354 
1355  /// Instrument attributes
1357  {
1358  return InstrumentAttributes ( getOptionalGroup (Tags::NoInstrAttrib) );
1359  }
1360 
1361  /// Events.
1362  Events events() const
1363  {
1364  return Events ( getGroup (Tags::NoEvents) );
1365  }
1366 
1367  /// Instrument Price Precision
1368  bool instrumentPricePrecision (UInt32& value) const
1369  {
1370  return get (Tags::InstrumentPricePrecision).toNumber (value);
1371  }
1372 
1373  /// Defines the minimum price movement in ticks (tick size).
1374  bool minPriceIncrement (Decimal& increment) const
1375  {
1376  return get (Tags::MinPriceIncrement).toNumber (increment);
1377  }
1378 
1379  /// Defines the minimum increment for trade prices in clearing notation (clearing tick size).
1381  {
1382  return get (Tags::MinPriceIncrementClearing).toNumber (price);
1383  }
1384 
1385  /// Defines the minimum price movement in the respective currency (tick value).
1387  {
1388  return getDecimal (Tags::MinPriceIncrementAmount);
1389  }
1390 
1391  /// Actual expiration day of the instrument (YYYYMMDD).
1392  bool maturityDate(Timestamp& date) const
1393  {
1394  UInt32 tmp;
1395  if (get(Tags::MaturityDate).toNumber(tmp))
1396  {
1398  return true;
1399  }
1400  return false;
1401  }
1402 
1403  /// Expiration month (YYYYMM).
1404  bool maturityMonthYear(UInt32& monthYear) const
1405  {
1406  return get(Tags::MaturityMonthYear).toNumber(monthYear);
1407  }
1408 
1409  /// Standard strategy type for complex instruments.
1410  bool securitySubType(UInt32& type) const
1411  {
1412  return get(Tags::SecuritySubType).toNumber(type);
1413  }
1414 
1415  /// Product identifier.
1417  {
1418  return getGroup (Tags::NoMarketSegments).at (0).getUInt32 (Tags::MarketSegmentID);
1419  }
1420 
1421  /// Implied market indicator
1423  {
1424  return getIntEnumFieldValue<ImpliedMarketIndicator> (getGroup (Tags::NoMarketSegments).at (0), Tags::ImpliedMarketIndicator);
1425  }
1426 
1427  /// Multileg model
1429  {
1430  return getIntEnumFieldValue<MultilegModel> (getGroup (Tags::NoMarketSegments).at (0), Tags::MultilegModel);
1431  }
1432 
1433  /// The unit in which an instrument is quoted/stated when buying or selling. Only for cash.
1435  {
1436  return getIntEnumFieldValue<PriceType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PriceType);
1437  }
1438 
1439  /// Only for cash.
1441  {
1442  return getIntEnumFieldValue<PostTradeAnonymityType> (getGroup (Tags::NoMarketSegments).at (0), Tags::PostTradeAnonymity);
1443  }
1444 
1445  /// Settlment Business Days
1446  bool settlBusinessDays (UInt32& value) const
1447  {
1448  return get (Tags::SettlBusinessDays).toNumber (value);
1449  }
1450 
1451  /// Bid side minimum quote quantity.
1453  {
1454  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinBidSize).toNumber(value);
1455  }
1456 
1457  /// Bid side minimum quote quantity.
1458  bool quoteSizeMinOfferSize(Decimal& value) const
1459  {
1460  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoQuoteSizeRules).at(0).get(Tags::MinOfferSize).toNumber(value);
1461  }
1462 
1463  /// Bid side minimum quote quantity.
1465  {
1466  return getGroup (Tags::NoMarketSegments).at(0).getGroup(Tags::NoPriceRangeRules).at(0).getUInt32(Tags::PriceRangeRuleID);
1467  }
1468 
1469  ///
1470  bool symbol(StringRef& value) const
1471  {
1472  return get(Tags::Symbol).toStringRef(value);
1473  }
1474 
1475  ///
1477  {
1478  return TradingSessionRules(getOptionalGroup(Tags::NoTradingSessionRules));
1479  }
1480 
1481  private:
1482  friend class InstrumentSnapshotWrapper;
1484 
1485  InstrumentSnapshot (const void* impl)
1486  : Message (impl)
1487  {
1488  }
1489  };
1490  }
1491  }
1492 }
InstrumentAttributes instrumentAttributes() const
Instrument attributes.
bool minTradeVol(Decimal &value) const
The minimum tradable unit of a bond.
const Tag NoInstrumentParties
Definition: Tags.h:210
bool minPriceIncrementClearing(Decimal &price) const
Defines the minimum increment for trade prices in clearing notation (clearing tick size)...
MarketSegmentId marketSegmentId() const
Product identifier.
const Tag MinPriceIncrement
Definition: Tags.h:89
PostTradeAnonymityType::Enum postTradeAnonymity() const
Only for cash.
bool legRatioMultiplier(UInt32 &value) const
Common integer multiple of the option legs for Option Volatility Strategies.
const Tag UnderlyingSecurityID
Definition: Tags.h:157
AccruedInterestCalculationMethod::Enum couponDayCount() const
Defines the Accrued interest Calculation Method.
bool instrumentPricePrecision(UInt32 &value) const
Instrument Price Precision.
bool quotingStartTime(StringRef &value) const
QuotingStartTime.
const Tag NoTradingSessionRules
Definition: Tags.h:232
bool minPriceIncrement(Decimal &increment) const
Defines the minimum price movement in ticks (tick size).
const Tag LowExercisePriceOptionIndicator
Definition: Tags.h:150
bool contractMonthYear(UInt32 &value)
Contract start month.
InstrumentType::Enum productComplex() const
Type of Market Data update action.
ContractFrequency::Enum contractFrequency() const
Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
bool contractMultiplier(Decimal &multiplier) const
Contract Multiplier.
InstrumentPartyRole::Enum role() const
const Tag ContractDisplayInstruction
Definition: Tags.h:284
bool quoteSizeRuleMinBidSize(Decimal &value) const
Bid side minimum quote quantity.
const Tag VolatilityCorridorIntradayAuction
Definition: Tags.h:308
ValuationMethod::Enum valuationMethod() const
Traditional or futures margin style.
bool volatilityCorridorContinuous(UInt32 &value) const
Reference to Volatility Corridor Table in Continuous.
StringRef id() const
Identifies a party associated with an instrument.
MultilegModel::Enum multilegModel() const
Multileg model.
bool couponPaymentDate(UInt32 &value) const
Upcoming Coupon payment date.
InstrumentPartyIDSource::Enum idSource() const
const Tag VolatilityCorridorOpeningAuction
Definition: Tags.h:307
DisplayDayOfWeek::Enum displayDayOfWeek() const
The day of week of the weekly contract.
bool previousCouponPaymentDate(UInt32 &value) const
Previous coupon payment date.
const Tag TradingSessionSubID
Definition: Tags.h:77
ContractDisplayInstruction::Enum contractDisplayInstruction() const
Defines the instrument display instruction.
const Tag PostTradeAnonymity
Definition: Tags.h:222
bool couponRate(Decimal &value) const
Instrument identifier of the leg security.
DepositType::Enum depositType() const
DepositType.
const Tag InstrumentPartyRoleQualifier
Definition: Tags.h:216
bool settlCurrency(StringRef &desc) const
Settlement currency.
bool displayRelativeDay(UInt32 &value)
Display Relative Day.
const Tag InstrumentPartyRole
Definition: Tags.h:215
bool displayMonth(UInt32 &value)
Display Month.
bool transactTime(UInt64 &time) const
Transact Time.
bool securityDesc(StringRef &desc) const
Security description.
InstrumentAuctionType::Enum instrumentAuctionType() const
InstrumentAuctionType.
PriceType::Enum priceType() const
The unit in which an instrument is quoted/stated when buying or selling. Only for cash...
const Tag InstrumentPartyIDSource
Definition: Tags.h:214
const Tag VolatilityCorridorContinuous
Definition: Tags.h:310
SecurityId securityId() const
Instrument identifier.
bool optAttribute(UInt32 &attribute) const
Version of an option. Version can change as a result of corporate actions or events.
const Tag MinPriceIncrementAmount
Definition: Tags.h:97
DisplaySeason::Enum displaySeason() const
Defines the instrument display instruction.
unsigned int UInt32
Definition: Numeric.h:41
Definition: Defines.h:30
Decimal type for better precision.
Definition: Numeric.h:63
const Tag LegRatioMultiplier
Definition: Tags.h:287
const Tag InstrumentPricePrecision
Definition: Tags.h:149
TradingSessionSubID::Enum tradingSessionSubID() const
Defines the trading session sub ID.
bool volatilityCorridorIntradayAuction(UInt32 &value) const
Reference to Volatility Corridor Table for Intraday Auction.
Indicates timestamp in "YYYYMMDD" format.
Definition: Timestamp.h:70
Int64 SecurityId
Alias for Security Id type.
Definition: Defines.h:51
const Tag ContractGenerationNumber
Definition: Tags.h:121
bool currency(StringRef &value) const
Currency as published in ISO 4217.
InstrumentSnapshotLegs legs() const
Legs.
bool securitySubType(UInt32 &type) const
Standard strategy type for complex instruments.
bool contractGenerationNumber(UInt32 &number) const
Contract generation.
UInt32 tradingSessionID() const
Trading Session ID.
const Tag UnderlyingMarketSegmentID
Definition: Tags.h:289
bool issueDate(UInt32 &date) const
Issue date of instrument.
const Tag StrikePricePrecision
Definition: Tags.h:148
ExerciseStyle::Enum exerciseStyle() const
Exercise Style.
bool quoteSizeMinOfferSize(Decimal &value) const
Bid side minimum quote quantity.
const Tag DisplayRelativeDay
Definition: Tags.h:299
ImpliedMarketIndicator::Enum impliedMarketIndicator() const
Implied market indicator.
bool securityExchange(StringRef &exchange) const
MIC (ISO 10383), used to identify an instrument of a co-operation partner.
bool underlyingMarketSegmentID(UInt32 &val) const
Refers to MarketSegmentID (1300) from the underlying Product Snapshot.
bool underlyingSecurityID(Int64 &val) const
Refers to SecurityID (48) from the underlying Instrument Snapshot.
bool contractDate(UInt32 &value)
Actual contract start date.
FlatIndicator::Enum flatIndicator() const
The Flat Indicator of a bond.
Represents timestamp without time-zone information.
Definition: Timestamp.h:87
bool maturityMonthYear(UInt32 &monthYear) const
Expiration month (YYYYMM).
CoverIndicator::Enum coverIndicator() const
CoverIndicator.
bool cfiCode(StringRef &desc) const
Indicates the type of security using ISO 10962 standard.
bool displayDay(UInt32 &value)
Display Day.
bool isPrimary() const
Defines, if this contract based on its contract generation cycle, is considered primary.
ContractCycleSubType::Enum contractCycleSubType() const
Indicates the kind of regular expiration pattern, in the context of ContractCycleType(30865).
ContractIdentificationEligibility::Enum contractIdentificationEligibility() const
Defines the granularity which suffice to identify a standard e.g. non - flexible contract uniquely wi...
SecurityType::Enum securityType() const
Type of security.
ContractCycleType::Enum contractCycleType() const
Defines the instrument cycle type.
bool strikePricePrecision(UInt32 &precision) const
Strike Price Precision.
const Tag SecurityAltIDSource
Definition: Tags.h:68
bool displayName(StringRef &desc) const
Display Name.
bool settlBusinessDays(UInt32 &value) const
Settlment Business Days.
bool lowExercisePriceOptionIndicator() const
Lepo Flag.
bool assetSubType(UInt32 &val) const
AssetSubType.
StringRef securityAltID() const
Alternate instrument identifier.
bool priorSettlPrice(Decimal &price) const
Previous day&#39;s settlement price. Converted in trading notation in case of variance futures...
CouponType::Enum couponType() const
Coupon Type.
WarrantType::Enum warrantType() const
WarrantType.
InstrumentParties instrumentParties() const
Instrument parties.
StringRef countryOfIssue() const
The accrued interest is rounded to the 12th decimal except for Country(421) = HU, rounded to the 7th ...
const Tag ContractMultiplier
Definition: Tags.h:51
Exposes list of Instrument scope operators.
SecurityStatus::Enum securityStatus() const
Security Status.
const Tag ContractCycleSubType
Definition: Tags.h:295
bool volatilityCorridorClosingAuction(UInt32 &value) const
Reference to Volatility Corridor Table for Closing Auction.
bool volatilityCorridorOpeningAuction(UInt32 &value) const
Reference to Volatility Corridor Table for Opening Auction.
PutOrCall::Enum putOrCall() const
Put Or Call.
InstrumentPartyRoleQualifier::Enum roleQualifier() const
InstrumentAttributeType::Enum type() const
const Tag ImpliedMarketIndicator
Definition: Tags.h:96
Decimal minPriceIncrementAmount() const
Defines the minimum price movement in the respective currency (tick value).
bool contractDateType(StringRef &value)
A symbol to describe the type of ContractDate.
UInt32 eventDate() const
Event Date.
UInt32 MarketSegmentId
Alias for Market Segment ID type.
Definition: Defines.h:40
const Tag ContractIdentificationEligibility
Definition: Tags.h:293
bool origStrikePrice(Decimal &price) const
Original strike price prior to corporate action, e.g. 5.20.
Alternate identifier entry.
const Tag PreviousCouponPaymentDate
Definition: Tags.h:247
bool priceDelta(Decimal &value) const
Previous day’s option delta provided for option instruments only.
bool strikePrice(Decimal &price) const
Strike Price.
const Tag InstrumentAuctionType
Definition: Tags.h:267
StringRef underlyingSymbol() const
Underlying symbol.
const Tag MinPriceIncrementClearing
Definition: Tags.h:220
bool refTickTableID(UInt32 &time) const
Reference to tick size table identifier from product level message.
const Tag MaturityMonthYear
Definition: Tags.h:46
bool unitOfMeasure(StringRef &val) const
UnitOfMeasure.
StringRef securityAltIDSource() const
Security alternate id source.
const Tag VolatilityCorridorClosingAuction
Definition: Tags.h:309
SecurityAlts securityAlts() const
Entries.
bool displayWeek(UInt32 &value)
Display Week.
EventType::Enum eventType() const
Event Type.
UInt32 priceRangeRuleID() const
Bid side minimum quote quantity.
static Timestamp parse(const std::string &, TimestampFormat::Enum=TimestampFormat::YYYYMMDDHHMMSSNsec)
bool quotingEndTime(StringRef &value) const
QuotingEndTime.
bool assetType(UInt32 &val) const
AssetType.
LastFragment::Enum lastFragment() const
Indicates whether this message is the last in a sequence of messages that together convey a joint lis...
bool displayQuarter(UInt32 &value)
The Display Quarter denotes the three-month period inside a year.
bool displayYear(UInt32 &value)
Display Year.
const Tag SecurityExchange
Definition: Tags.h:50
bool maturityDate(Timestamp &date) const
Actual expiration day of the instrument (YYYYMMDD).
Exposes list of available security types.