OnixS C++ Euronext Optiq MDG Handler 1.5.0
API documentation
Loading...
Searching...
No Matches
Messages.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
23#include <cassert>
24#include <stdexcept>
25
26#include <OnixS/Euronext/MarketData/OptiqMdg/ABI.h>
27#include <OnixS/Euronext/MarketData/OptiqMdg/messaging/Forwards.h>
28#include <OnixS/Euronext/MarketData/OptiqMdg/messaging/Composites.h>
29#include <OnixS/Euronext/MarketData/OptiqMdg/messaging/SbeMessage.h>
30
31ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_BEGIN
32
34ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
35StartOfDay
36: SbeMessage
37{
39 typedef SchemaTraits Schema;
40
42 enum { TemplateId = 1101 };
43
45 StartOfDay() =default;
46
48 StartOfDay(
49 const void* data,
50 EncodedLength length)
51 : SbeMessage(data, length)
52 {
53 checkCompatibility();
54 }
55
57 explicit
58 StartOfDay(
59 const SbeMessage& message)
60 : SbeMessage(message)
61 {
62 assert(message.valid());
63
64 checkCompatibility();
65 }
66
68 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
69 bool seqNum(Uint64& value) const
70 noexcept
71 {
72 constexpr BlockLength offset = 0;
73
74 return ordinary(value, offset, NullUint64());
75 }
76
78 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
79 bool sessionTradingDay(Uint16& value) const
80 noexcept
81 {
82 constexpr BlockLength offset = 8;
83
84 return ordinary(value, offset, NullUint16());
85 }
86
88 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
89 constexpr
90 static
91 BlockLength
92 minimalBlockLength(
93 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
94 noexcept
95 {
96 return
97 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
98 10;
99 }
100
102 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
103 constexpr
104 static BlockLength blockLength(SchemaVersion version)
105 noexcept
106 {
107 return
108 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
109 minimalBlockLength(version);
110 }
111
113 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
114 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
115 constexpr
116 static
117 MessageSize
118 getMinimalVariableFieldsSize(
119 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
120 {
121 return
122 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
123 0;
124 }
125
127 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
128 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
129 constexpr
130 static StrRef className()
131 noexcept
132 {
133 return constructStrRef("StartOfDay");
134 }
135
137 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
138 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
139 constexpr
140 static StrRef fixType()
141 noexcept
142 {
143 return constructStrRef("StartOfDay");
144 }
145
147 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
148 std::string toString() const;
149
150private:
151 void checkLength(
152 EncodedLength length, SchemaVersion version) const
153 {
154 const EncodedLength minimalRequiredLength =
155 minimalBlockLength(version) +
156 MessageHeader::Size +
157 getMinimalVariableFieldsSize(version);
158
159 checkBinaryLength(
160 *this, length, minimalRequiredLength);
161 }
162
163 void checkCompatibility() const
164 {
165 assert(TemplateId == templateId());
166
167 checkSchema<Schema>(schemaId(), version());
168 checkLength(bufferSize(), version());
169 }
170};
171
173ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
174EndOfDay
175: SbeMessage
176{
178 typedef SchemaTraits Schema;
179
181 enum { TemplateId = 1102 };
182
184 EndOfDay() =default;
185
187 EndOfDay(
188 const void* data,
189 EncodedLength length)
190 : SbeMessage(data, length)
191 {
192 checkCompatibility();
193 }
194
196 explicit
197 EndOfDay(
198 const SbeMessage& message)
199 : SbeMessage(message)
200 {
201 assert(message.valid());
202
203 checkCompatibility();
204 }
205
207 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
208 bool seqNum(Uint64& value) const
209 noexcept
210 {
211 constexpr BlockLength offset = 0;
212
213 return ordinary(value, offset, NullUint64());
214 }
215
217 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
218 bool sessionTradingDay(Uint16& value) const
219 noexcept
220 {
221 constexpr BlockLength offset = 8;
222
223 return ordinary(value, offset, NullUint16());
224 }
225
227 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
228 constexpr
229 static
230 BlockLength
231 minimalBlockLength(
232 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
233 noexcept
234 {
235 return
236 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
237 10;
238 }
239
241 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
242 constexpr
243 static BlockLength blockLength(SchemaVersion version)
244 noexcept
245 {
246 return
247 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
248 minimalBlockLength(version);
249 }
250
252 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
253 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
254 constexpr
255 static
256 MessageSize
257 getMinimalVariableFieldsSize(
258 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
259 {
260 return
261 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
262 0;
263 }
264
266 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
267 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
268 constexpr
269 static StrRef className()
270 noexcept
271 {
272 return constructStrRef("EndOfDay");
273 }
274
276 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
277 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
278 constexpr
279 static StrRef fixType()
280 noexcept
281 {
282 return constructStrRef("EndOfDay");
283 }
284
286 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
287 std::string toString() const;
288
289private:
290 void checkLength(
291 EncodedLength length, SchemaVersion version) const
292 {
293 const EncodedLength minimalRequiredLength =
294 minimalBlockLength(version) +
295 MessageHeader::Size +
296 getMinimalVariableFieldsSize(version);
297
298 checkBinaryLength(
299 *this, length, minimalRequiredLength);
300 }
301
302 void checkCompatibility() const
303 {
304 assert(TemplateId == templateId());
305
306 checkSchema<Schema>(schemaId(), version());
307 checkLength(bufferSize(), version());
308 }
309};
310
312ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
313HealthStatus
314: SbeMessage
315{
317 typedef SchemaTraits Schema;
318
320 enum { TemplateId = 1103 };
321
323 HealthStatus() =default;
324
326 HealthStatus(
327 const void* data,
328 EncodedLength length)
329 : SbeMessage(data, length)
330 {
331 checkCompatibility();
332 }
333
335 explicit
336 HealthStatus(
337 const SbeMessage& message)
338 : SbeMessage(message)
339 {
340 assert(message.valid());
341
342 checkCompatibility();
343 }
344
346 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
347 bool seqNum(Uint64& value) const
348 noexcept
349 {
350 constexpr BlockLength offset = 0;
351
352 return ordinary(value, offset, NullUint64());
353 }
354
356 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
357 bool eventTime(Uint64& value) const
358 noexcept
359 {
360 constexpr BlockLength offset = 8;
361
362 return ordinary(value, offset, NullUint64());
363 }
364
366 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
367 constexpr
368 static
369 BlockLength
370 minimalBlockLength(
371 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
372 noexcept
373 {
374 return
375 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
376 16;
377 }
378
380 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
381 constexpr
382 static BlockLength blockLength(SchemaVersion version)
383 noexcept
384 {
385 return
386 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
387 minimalBlockLength(version);
388 }
389
391 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
392 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
393 constexpr
394 static
395 MessageSize
396 getMinimalVariableFieldsSize(
397 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
398 {
399 return
400 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
401 0;
402 }
403
405 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
406 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
407 constexpr
408 static StrRef className()
409 noexcept
410 {
411 return constructStrRef("HealthStatus");
412 }
413
415 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
416 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
417 constexpr
418 static StrRef fixType()
419 noexcept
420 {
421 return constructStrRef("HealthStatus");
422 }
423
425 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
426 std::string toString() const;
427
428private:
429 void checkLength(
430 EncodedLength length, SchemaVersion version) const
431 {
432 const EncodedLength minimalRequiredLength =
433 minimalBlockLength(version) +
434 MessageHeader::Size +
435 getMinimalVariableFieldsSize(version);
436
437 checkBinaryLength(
438 *this, length, minimalRequiredLength);
439 }
440
441 void checkCompatibility() const
442 {
443 assert(TemplateId == templateId());
444
445 checkSchema<Schema>(schemaId(), version());
446 checkLength(bufferSize(), version());
447 }
448};
449
451ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
452TechnicalNotification
453: SbeMessage
454{
456 typedef SchemaTraits Schema;
457
459 enum { TemplateId = 1106 };
460
462 TechnicalNotification() =default;
463
465 TechnicalNotification(
466 const void* data,
467 EncodedLength length)
468 : SbeMessage(data, length)
469 {
470 checkCompatibility();
471 }
472
474 explicit
475 TechnicalNotification(
476 const SbeMessage& message)
477 : SbeMessage(message)
478 {
479 assert(message.valid());
480
481 checkCompatibility();
482 }
483
485 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
486 bool seqNum(Uint64& value) const
487 noexcept
488 {
489 constexpr BlockLength offset = 0;
490
491 return ordinary(value, offset, NullUint64());
492 }
493
495 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
496 TechnicalNotificationType::Enum
497 technicalNotificationType() const
498 noexcept
499 {
500 constexpr BlockLength offset = 8;
501
502 return enumeration<TechnicalNotificationType>(offset);
503 }
504
506 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
507 bool rebroadcastIndicator(UnsignedChar& value) const
508 noexcept
509 {
510 constexpr BlockLength offset = 9;
511
512 return ordinary(value, offset, NullUnsignedChar());
513 }
514
516 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
517 bool retransmissionStartTime(Uint64& value) const
518 noexcept
519 {
520 constexpr BlockLength offset = 10;
521
522 return ordinary(value, offset, NullUint64());
523 }
524
526 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
527 bool retransmissionEndTime(Uint64& value) const
528 noexcept
529 {
530 constexpr BlockLength offset = 18;
531
532 return ordinary(value, offset, NullUint64());
533 }
534
536 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
537 bool symbolIndex(Uint32& value) const
538 noexcept
539 {
540 constexpr BlockLength offset = 26;
541
542 return ordinary(value, offset, NullUint32());
543 }
544
546 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
547 constexpr
548 static
549 BlockLength
550 minimalBlockLength(
551 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
552 noexcept
553 {
554 return
555 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
556 30;
557 }
558
560 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
561 constexpr
562 static BlockLength blockLength(SchemaVersion version)
563 noexcept
564 {
565 return
566 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
567 minimalBlockLength(version);
568 }
569
571 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
572 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
573 constexpr
574 static
575 MessageSize
576 getMinimalVariableFieldsSize(
577 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
578 {
579 return
580 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
581 0;
582 }
583
585 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
586 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
587 constexpr
588 static StrRef className()
589 noexcept
590 {
591 return constructStrRef("TechnicalNotification");
592 }
593
595 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
596 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
597 constexpr
598 static StrRef fixType()
599 noexcept
600 {
601 return constructStrRef("TechnicalNotification");
602 }
603
605 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
606 std::string toString() const;
607
608private:
609 void checkLength(
610 EncodedLength length, SchemaVersion version) const
611 {
612 const EncodedLength minimalRequiredLength =
613 minimalBlockLength(version) +
614 MessageHeader::Size +
615 getMinimalVariableFieldsSize(version);
616
617 checkBinaryLength(
618 *this, length, minimalRequiredLength);
619 }
620
621 void checkCompatibility() const
622 {
623 assert(TemplateId == templateId());
624
625 checkSchema<Schema>(schemaId(), version());
626 checkLength(bufferSize(), version());
627 }
628};
629
631ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
632MarketUpdate
633: SbeMessage
634{
636 typedef SchemaTraits Schema;
637
639 enum { TemplateId = 1001 };
640
643 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
644 UpdatesEntry : SbeGroupEntry
645 <
646 GroupSizeEncoding::BlockLength
647 >
648 {
650 typedef
651 SbeGroupEntry
652 <
653 GroupSizeEncoding::BlockLength
654 >
655 Base;
656
659 UpdatesEntry(
660 const void* data,
661 EncodedLength length,
662 SchemaVersion version)
663 : Base(data, numericCast<Base::BlockLength>(length), version)
664 {
665 assert(version >= Schema::MinimalVersion);
666 assert(length >= minimalBlockLength(version));
667 }
668
670 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
671 MarketDataUpdateType::Enum
672 updateType() const
673 noexcept
674 {
675 constexpr BlockLength offset = 0;
676
677 return enumeration<MarketDataUpdateType>(offset);
678 }
679
681 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
682 bool symbolIndex(Uint32& value) const
683 noexcept
684 {
685 constexpr BlockLength offset = 1;
686
687 return ordinary(value, offset, NullUint32());
688 }
689
691 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
692 bool numberOfOrders(Uint16& value) const
693 noexcept
694 {
695 constexpr BlockLength offset = 5;
696
697 return ordinary(value, offset, NullUint16());
698 }
699
701 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
702 bool price(Int64& value) const
703 noexcept
704 {
705 constexpr BlockLength offset = 7;
706
707 return ordinary(value, offset, NullInt64());
708 }
709
711 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
712 bool quantity(Uint64& value) const
713 noexcept
714 {
715 constexpr BlockLength offset = 15;
716
717 return ordinary(value, offset, NullUint64());
718 }
719
722 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
723 constexpr
724 static BlockLength blockLength(SchemaVersion version)
725 noexcept
726 {
727 return
728 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
729 minimalBlockLength(version);
730 }
731
734 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
735 constexpr
736 static
737 BlockLength
738 minimalBlockLength(
739 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
740 noexcept
741 {
742 return
743 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
744 23;
745 }
746
748 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
749 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
750 constexpr
751 static StrRef className()
752 noexcept
753 {
754 return constructStrRef("MarketUpdate.UpdatesEntry");
755 }
756 };
757
759 typedef
760 SbeGroup<UpdatesEntry, GroupSizeEncoding, MessageSize>
761 Updates;
762
764 MarketUpdate() =default;
765
767 MarketUpdate(
768 const void* data,
769 EncodedLength length)
770 : SbeMessage(data, length)
771 {
772 checkCompatibility();
773 }
774
776 explicit
777 MarketUpdate(
778 const SbeMessage& message)
779 : SbeMessage(message)
780 {
781 assert(message.valid());
782
783 checkCompatibility();
784 }
785
787 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
788 bool seqNum(Uint64& value) const
789 noexcept
790 {
791 constexpr BlockLength offset = 0;
792
793 return ordinary(value, offset, NullUint64());
794 }
795
797 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
798 bool rebroadcastIndicator(UnsignedChar& value) const
799 noexcept
800 {
801 constexpr BlockLength offset = 8;
802
803 return ordinary(value, offset, NullUnsignedChar());
804 }
805
807 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
808 Emm::Enum eMM() const
809 noexcept
810 {
811 constexpr BlockLength offset = 9;
812
813 return enumeration<Emm>(offset);
814 }
815
817 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
818 bool eventTime(Uint64& value) const
819 noexcept
820 {
821 constexpr BlockLength offset = 10;
822
823 return ordinary(value, offset, NullUint64());
824 }
825
827 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
828 Updates updates() const
829 noexcept
830 {
831 return getGroup<Updates>(UpdatesAccess(), *this);
832 }
833
835 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
836 constexpr
837 static
838 BlockLength
839 minimalBlockLength(
840 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
841 noexcept
842 {
843 return
844 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
845 18;
846 }
847
849 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
850 constexpr
851 static BlockLength blockLength(SchemaVersion version)
852 noexcept
853 {
854 return
855 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
856 minimalBlockLength(version);
857 }
858
860 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
861 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
862 constexpr
863 static
864 MessageSize
865 getMinimalVariableFieldsSize(
866 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
867 {
868 return
869 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
870 static_cast<MessageSize>(Updates::EmptySize);
871 }
872
874 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
875 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
876 constexpr
877 static StrRef className()
878 noexcept
879 {
880 return constructStrRef("MarketUpdate");
881 }
882
884 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
885 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
886 constexpr
887 static StrRef fixType()
888 noexcept
889 {
890 return constructStrRef("MarketUpdate");
891 }
892
894 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
895 std::string toString() const;
896
897private:
898 void checkLength(
899 EncodedLength length, SchemaVersion version) const
900 {
901 const EncodedLength minimalRequiredLength =
902 minimalBlockLength(version) +
903 MessageHeader::Size +
904 getMinimalVariableFieldsSize(version);
905
906 checkBinaryLength(
907 *this, length, minimalRequiredLength);
908 }
909
911 void checkVarLenFields() const
912 {
913 groups().
914 checkTail<Updates>();
915 }
916
917 void checkCompatibility() const
918 {
919 assert(TemplateId == templateId());
920
921 checkSchema<Schema>(schemaId(), version());
922 checkLength(bufferSize(), version());
923 checkVarLenFields();
924 }
925
927 struct UpdatesAccess
928 {
929 Updates operator()(const MarketUpdate& obj) const
930 noexcept
931 {
932 return obj.
933 groups().
934 head<Updates>();
935 }
936 };
937};
938
940ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
941OrderUpdate
942: SbeMessage
943{
945 typedef SchemaTraits Schema;
946
948 enum { TemplateId = 1002 };
949
952 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
953 OrdersEntry : SbeGroupEntry
954 <
955 GroupSizeEncoding::BlockLength
956 >
957 {
959 typedef
960 SbeGroupEntry
961 <
962 GroupSizeEncoding::BlockLength
963 >
964 Base;
965
968 OrdersEntry(
969 const void* data,
970 EncodedLength length,
971 SchemaVersion version)
972 : Base(data, numericCast<Base::BlockLength>(length), version)
973 {
974 assert(version >= Schema::MinimalVersion);
975 assert(length >= minimalBlockLength(version));
976 }
977
979 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
980 bool symbolIndex(Uint32& value) const
981 noexcept
982 {
983 constexpr BlockLength offset = 0;
984
985 return ordinary(value, offset, NullUint32());
986 }
987
989 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
990 MarketDataActionType::Enum
991 actionType() const
992 noexcept
993 {
994 constexpr BlockLength offset = 4;
995
996 return enumeration<MarketDataActionType>(offset);
997 }
998
1000 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1001 bool orderPriority(Uint64& value) const
1002 noexcept
1003 {
1004 constexpr BlockLength offset = 5;
1005
1006 return ordinary(value, offset, NullUint64());
1007 }
1008
1010 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1011 bool previousPriority(Uint64& value) const
1012 noexcept
1013 {
1014 constexpr BlockLength offset = 13;
1015
1016 return ordinary(value, offset, NullUint64());
1017 }
1018
1020 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1021 bool orderType(OrderType::Enum& value) const
1022 noexcept
1023 {
1024 constexpr BlockLength offset = 21;
1025
1026 return enumeration<OrderType>(value, offset, NullUInt8());
1027 }
1028
1030 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1031 bool orderPx(Int64& value) const
1032 noexcept
1033 {
1034 constexpr BlockLength offset = 22;
1035
1036 return ordinary(value, offset, NullInt64());
1037 }
1038
1040 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1041 bool orderSide(OrderSide::Enum& value) const
1042 noexcept
1043 {
1044 constexpr BlockLength offset = 30;
1045
1046 return enumeration<OrderSide>(value, offset, NullUInt8());
1047 }
1048
1050 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1051 bool orderQuantity(Uint64& value) const
1052 noexcept
1053 {
1054 constexpr BlockLength offset = 31;
1055
1056 return ordinary(value, offset, NullUint64());
1057 }
1058
1060 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1061 bool pegOffset(Int8& value) const
1062 noexcept
1063 {
1064 constexpr BlockLength offset = 39;
1065
1066 return ordinary(value, offset, NullInt8());
1067 }
1068
1071 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1072 constexpr
1073 static BlockLength blockLength(SchemaVersion version)
1074 noexcept
1075 {
1076 return
1077 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1078 minimalBlockLength(version);
1079 }
1080
1083 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1084 constexpr
1085 static
1086 BlockLength
1087 minimalBlockLength(
1088 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1089 noexcept
1090 {
1091 return
1092 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1093 40;
1094 }
1095
1097 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1098 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1099 constexpr
1100 static StrRef className()
1101 noexcept
1102 {
1103 return constructStrRef("OrderUpdate.OrdersEntry");
1104 }
1105 };
1106
1108 typedef
1109 SbeGroup<OrdersEntry, GroupSizeEncoding, MessageSize>
1110 Orders;
1111
1113 OrderUpdate() =default;
1114
1116 OrderUpdate(
1117 const void* data,
1118 EncodedLength length)
1119 : SbeMessage(data, length)
1120 {
1121 checkCompatibility();
1122 }
1123
1125 explicit
1126 OrderUpdate(
1127 const SbeMessage& message)
1128 : SbeMessage(message)
1129 {
1130 assert(message.valid());
1131
1132 checkCompatibility();
1133 }
1134
1136 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1137 bool seqNum(Uint64& value) const
1138 noexcept
1139 {
1140 constexpr BlockLength offset = 0;
1141
1142 return ordinary(value, offset, NullUint64());
1143 }
1144
1146 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1147 bool rebroadcastIndicator(UnsignedChar& value) const
1148 noexcept
1149 {
1150 constexpr BlockLength offset = 8;
1151
1152 return ordinary(value, offset, NullUnsignedChar());
1153 }
1154
1156 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1157 Emm::Enum eMM() const
1158 noexcept
1159 {
1160 constexpr BlockLength offset = 9;
1161
1162 return enumeration<Emm>(offset);
1163 }
1164
1166 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1167 bool eventTime(Uint64& value) const
1168 noexcept
1169 {
1170 constexpr BlockLength offset = 10;
1171
1172 return ordinary(value, offset, NullUint64());
1173 }
1174
1176 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1177 Orders orders() const
1178 noexcept
1179 {
1180 return getGroup<Orders>(OrdersAccess(), *this);
1181 }
1182
1184 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1185 constexpr
1186 static
1187 BlockLength
1188 minimalBlockLength(
1189 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1190 noexcept
1191 {
1192 return
1193 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1194 18;
1195 }
1196
1198 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1199 constexpr
1200 static BlockLength blockLength(SchemaVersion version)
1201 noexcept
1202 {
1203 return
1204 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1205 minimalBlockLength(version);
1206 }
1207
1209 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1210 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1211 constexpr
1212 static
1213 MessageSize
1214 getMinimalVariableFieldsSize(
1215 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1216 {
1217 return
1218 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1219 static_cast<MessageSize>(Orders::EmptySize);
1220 }
1221
1223 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1224 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1225 constexpr
1226 static StrRef className()
1227 noexcept
1228 {
1229 return constructStrRef("OrderUpdate");
1230 }
1231
1233 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1234 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1235 constexpr
1236 static StrRef fixType()
1237 noexcept
1238 {
1239 return constructStrRef("OrderUpdate");
1240 }
1241
1243 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1244 std::string toString() const;
1245
1246private:
1247 void checkLength(
1248 EncodedLength length, SchemaVersion version) const
1249 {
1250 const EncodedLength minimalRequiredLength =
1251 minimalBlockLength(version) +
1252 MessageHeader::Size +
1253 getMinimalVariableFieldsSize(version);
1254
1255 checkBinaryLength(
1256 *this, length, minimalRequiredLength);
1257 }
1258
1260 void checkVarLenFields() const
1261 {
1262 groups().
1263 checkTail<Orders>();
1264 }
1265
1266 void checkCompatibility() const
1267 {
1268 assert(TemplateId == templateId());
1269
1270 checkSchema<Schema>(schemaId(), version());
1271 checkLength(bufferSize(), version());
1272 checkVarLenFields();
1273 }
1274
1276 struct OrdersAccess
1277 {
1278 Orders operator()(const OrderUpdate& obj) const
1279 noexcept
1280 {
1281 return obj.
1282 groups().
1283 head<Orders>();
1284 }
1285 };
1286};
1287
1289ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
1290PriceUpdate
1291: SbeMessage
1292{
1294 typedef SchemaTraits Schema;
1295
1297 enum { TemplateId = 1003 };
1298
1301 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
1302 PricesEntry : SbeGroupEntry
1303 <
1304 GroupSizeEncoding::BlockLength
1305 >
1306 {
1308 typedef
1309 SbeGroupEntry
1310 <
1311 GroupSizeEncoding::BlockLength
1312 >
1313 Base;
1314
1317 PricesEntry(
1318 const void* data,
1319 EncodedLength length,
1320 SchemaVersion version)
1321 : Base(data, numericCast<Base::BlockLength>(length), version)
1322 {
1323 assert(version >= Schema::MinimalVersion);
1324 assert(length >= minimalBlockLength(version));
1325 }
1326
1328 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1329 MarketDataPriceType::Enum
1330 priceType() const
1331 noexcept
1332 {
1333 constexpr BlockLength offset = 0;
1334
1335 return enumeration<MarketDataPriceType>(offset);
1336 }
1337
1339 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1340 bool symbolIndex(Uint32& value) const
1341 noexcept
1342 {
1343 constexpr BlockLength offset = 1;
1344
1345 return ordinary(value, offset, NullUint32());
1346 }
1347
1349 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1350 bool price(Int64& value) const
1351 noexcept
1352 {
1353 constexpr BlockLength offset = 5;
1354
1355 return ordinary(value, offset, NullInt64());
1356 }
1357
1359 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1360 bool quantity(Uint64& value) const
1361 noexcept
1362 {
1363 constexpr BlockLength offset = 13;
1364
1365 return ordinary(value, offset, NullUint64());
1366 }
1367
1369 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1370 bool imbalanceQty(Uint64& value) const
1371 noexcept
1372 {
1373 constexpr BlockLength offset = 21;
1374
1375 return ordinary(value, offset, NullUint64());
1376 }
1377
1379 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1380 bool
1381 imbalanceQtySide(
1382 ImbalanceQuantitySide::Enum& value) const
1383 noexcept
1384 {
1385 constexpr BlockLength offset = 29;
1386
1387 return enumeration<ImbalanceQuantitySide>(value, offset, NullUInt8());
1388 }
1389
1391 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1392 bool
1393 priceQualifier(
1394 PriceQualifier::Enum& value) const
1395 noexcept
1396 {
1397 constexpr BlockLength offset = 30;
1398
1399 return enumeration<PriceQualifier>(value, offset, NullUInt8());
1400 }
1401
1404 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1405 constexpr
1406 static BlockLength blockLength(SchemaVersion version)
1407 noexcept
1408 {
1409 return
1410 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1411 minimalBlockLength(version);
1412 }
1413
1416 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1417 constexpr
1418 static
1419 BlockLength
1420 minimalBlockLength(
1421 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1422 noexcept
1423 {
1424 return
1425 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1426 31;
1427 }
1428
1430 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1431 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1432 constexpr
1433 static StrRef className()
1434 noexcept
1435 {
1436 return constructStrRef("PriceUpdate.PricesEntry");
1437 }
1438 };
1439
1441 typedef
1442 SbeGroup<PricesEntry, GroupSizeEncoding, MessageSize>
1443 Prices;
1444
1446 PriceUpdate() =default;
1447
1449 PriceUpdate(
1450 const void* data,
1451 EncodedLength length)
1452 : SbeMessage(data, length)
1453 {
1454 checkCompatibility();
1455 }
1456
1458 explicit
1459 PriceUpdate(
1460 const SbeMessage& message)
1461 : SbeMessage(message)
1462 {
1463 assert(message.valid());
1464
1465 checkCompatibility();
1466 }
1467
1469 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1470 bool seqNum(Uint64& value) const
1471 noexcept
1472 {
1473 constexpr BlockLength offset = 0;
1474
1475 return ordinary(value, offset, NullUint64());
1476 }
1477
1479 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1480 bool rebroadcastIndicator(UnsignedChar& value) const
1481 noexcept
1482 {
1483 constexpr BlockLength offset = 8;
1484
1485 return ordinary(value, offset, NullUnsignedChar());
1486 }
1487
1489 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1490 Emm::Enum eMM() const
1491 noexcept
1492 {
1493 constexpr BlockLength offset = 9;
1494
1495 return enumeration<Emm>(offset);
1496 }
1497
1499 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1500 bool eventTime(Uint64& value) const
1501 noexcept
1502 {
1503 constexpr BlockLength offset = 10;
1504
1505 return ordinary(value, offset, NullUint64());
1506 }
1507
1509 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1510 Prices prices() const
1511 noexcept
1512 {
1513 return getGroup<Prices>(PricesAccess(), *this);
1514 }
1515
1517 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1518 constexpr
1519 static
1520 BlockLength
1521 minimalBlockLength(
1522 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1523 noexcept
1524 {
1525 return
1526 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1527 18;
1528 }
1529
1531 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1532 constexpr
1533 static BlockLength blockLength(SchemaVersion version)
1534 noexcept
1535 {
1536 return
1537 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1538 minimalBlockLength(version);
1539 }
1540
1542 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1543 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1544 constexpr
1545 static
1546 MessageSize
1547 getMinimalVariableFieldsSize(
1548 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1549 {
1550 return
1551 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1552 static_cast<MessageSize>(Prices::EmptySize);
1553 }
1554
1556 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1557 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1558 constexpr
1559 static StrRef className()
1560 noexcept
1561 {
1562 return constructStrRef("PriceUpdate");
1563 }
1564
1566 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1567 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1568 constexpr
1569 static StrRef fixType()
1570 noexcept
1571 {
1572 return constructStrRef("PriceUpdate");
1573 }
1574
1576 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1577 std::string toString() const;
1578
1579private:
1580 void checkLength(
1581 EncodedLength length, SchemaVersion version) const
1582 {
1583 const EncodedLength minimalRequiredLength =
1584 minimalBlockLength(version) +
1585 MessageHeader::Size +
1586 getMinimalVariableFieldsSize(version);
1587
1588 checkBinaryLength(
1589 *this, length, minimalRequiredLength);
1590 }
1591
1593 void checkVarLenFields() const
1594 {
1595 groups().
1596 checkTail<Prices>();
1597 }
1598
1599 void checkCompatibility() const
1600 {
1601 assert(TemplateId == templateId());
1602
1603 checkSchema<Schema>(schemaId(), version());
1604 checkLength(bufferSize(), version());
1605 checkVarLenFields();
1606 }
1607
1609 struct PricesAccess
1610 {
1611 Prices operator()(const PriceUpdate& obj) const
1612 noexcept
1613 {
1614 return obj.
1615 groups().
1616 head<Prices>();
1617 }
1618 };
1619};
1620
1622ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
1623FullTradeInformation
1624: SbeMessage
1625{
1627 typedef SchemaTraits Schema;
1628
1630 enum { TemplateId = 1004 };
1631
1634 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
1635 NotUsedGroup1Entry : SbeGroupEntry
1636 <
1637 GroupSizeEncoding::BlockLength
1638 >
1639 {
1641 typedef
1642 SbeGroupEntry
1643 <
1644 GroupSizeEncoding::BlockLength
1645 >
1646 Base;
1647
1650 NotUsedGroup1Entry(
1651 const void* data,
1652 EncodedLength length,
1653 SchemaVersion version)
1654 : Base(data, numericCast<Base::BlockLength>(length), version)
1655 {
1656 assert(version >= Schema::MinimalVersion);
1657 assert(length >= minimalBlockLength(version));
1658 }
1659
1662 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1663 constexpr
1664 static BlockLength blockLength(SchemaVersion version)
1665 noexcept
1666 {
1667 return
1668 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1669 minimalBlockLength(version);
1670 }
1671
1674 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1675 constexpr
1676 static
1677 BlockLength
1678 minimalBlockLength(
1679 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1680 noexcept
1681 {
1682 return
1683 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1684 0;
1685 }
1686
1688 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1689 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1690 constexpr
1691 static StrRef className()
1692 noexcept
1693 {
1694 return constructStrRef("FullTradeInformation.NotUsedGroup1Entry");
1695 }
1696 };
1697
1699 typedef
1700 SbeGroup<NotUsedGroup1Entry, GroupSizeEncoding, MessageSize>
1701 NotUsedGroup1;
1702
1704 FullTradeInformation() =default;
1705
1707 FullTradeInformation(
1708 const void* data,
1709 EncodedLength length)
1710 : SbeMessage(data, length)
1711 {
1712 checkCompatibility();
1713 }
1714
1716 explicit
1717 FullTradeInformation(
1718 const SbeMessage& message)
1719 : SbeMessage(message)
1720 {
1721 assert(message.valid());
1722
1723 checkCompatibility();
1724 }
1725
1727 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1728 bool seqNum(Uint64& value) const
1729 noexcept
1730 {
1731 constexpr BlockLength offset = 0;
1732
1733 return ordinary(value, offset, NullUint64());
1734 }
1735
1737 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1738 bool rebroadcastIndicator(UnsignedChar& value) const
1739 noexcept
1740 {
1741 constexpr BlockLength offset = 8;
1742
1743 return ordinary(value, offset, NullUnsignedChar());
1744 }
1745
1747 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1748 Emm::Enum eMM() const
1749 noexcept
1750 {
1751 constexpr BlockLength offset = 9;
1752
1753 return enumeration<Emm>(offset);
1754 }
1755
1757 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1758 bool eventTime(Uint64& value) const
1759 noexcept
1760 {
1761 constexpr BlockLength offset = 10;
1762
1763 return ordinary(value, offset, NullUint64());
1764 }
1765
1767 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1768 bool symbolIndex(Uint32& value) const
1769 noexcept
1770 {
1771 constexpr BlockLength offset = 18;
1772
1773 return ordinary(value, offset, NullUint32());
1774 }
1775
1777 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1778 StrRef tradingDateTime() const
1779 noexcept
1780 {
1781 constexpr BlockLength offset = 22;
1782 constexpr BlockLength length = 27;
1783
1784 return fixedStr<length>(offset);
1785 }
1786
1788 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1789 bool publicationDateTime(StrRef& value) const
1790 noexcept
1791 {
1792 constexpr BlockLength offset = 49;
1793 constexpr BlockLength length = 27;
1794
1795 return fixedStr<length>(value, offset);
1796 }
1797
1799 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1800 TradeType::Enum tradeType() const
1801 noexcept
1802 {
1803 constexpr BlockLength offset = 76;
1804
1805 return enumeration<TradeType>(offset);
1806 }
1807
1809 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1810 bool mifidInstrumentIdType(StrRef& value) const
1811 noexcept
1812 {
1813 constexpr BlockLength offset = 77;
1814 constexpr BlockLength length = 4;
1815
1816 return fixedStr<length>(value, offset);
1817 }
1818
1820 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1821 bool mifidInstrumentId(StrRef& value) const
1822 noexcept
1823 {
1824 constexpr BlockLength offset = 81;
1825 constexpr BlockLength length = 12;
1826
1827 return fixedStr<length>(value, offset);
1828 }
1829
1831 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1832 StrRef mifidExecutionId() const
1833 noexcept
1834 {
1835 constexpr BlockLength offset = 93;
1836 constexpr BlockLength length = 52;
1837
1838 return fixedStr<length>(offset);
1839 }
1840
1842 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1843 bool mifidPrice(StrRef& value) const
1844 noexcept
1845 {
1846 constexpr BlockLength offset = 145;
1847 constexpr BlockLength length = 20;
1848
1849 return fixedStr<length>(value, offset);
1850 }
1851
1853 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1854 StrRef mifidQuantity() const
1855 noexcept
1856 {
1857 constexpr BlockLength offset = 165;
1858 constexpr BlockLength length = 20;
1859
1860 return fixedStr<length>(offset);
1861 }
1862
1864 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1865 bool mifidPriceNotation(StrRef& value) const
1866 noexcept
1867 {
1868 constexpr BlockLength offset = 185;
1869 constexpr BlockLength length = 4;
1870
1871 return fixedStr<length>(value, offset);
1872 }
1873
1875 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1876 bool mifidCurrency(StrRef& value) const
1877 noexcept
1878 {
1879 constexpr BlockLength offset = 189;
1880 constexpr BlockLength length = 3;
1881
1882 return fixedStr<length>(value, offset);
1883 }
1884
1886 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1887 bool miFIdQtyinMsrmtUnitNotation(StrRef& value) const
1888 noexcept
1889 {
1890 constexpr BlockLength offset = 192;
1891 constexpr BlockLength length = 25;
1892
1893 return fixedStr<length>(value, offset);
1894 }
1895
1897 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1898 bool mifidQuantityMeasurementUnit(StrRef& value) const
1899 noexcept
1900 {
1901 constexpr BlockLength offset = 217;
1902 constexpr BlockLength length = 20;
1903
1904 return fixedStr<length>(value, offset);
1905 }
1906
1908 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1909 bool miFIdNotionalAmount(StrRef& value) const
1910 noexcept
1911 {
1912 constexpr BlockLength offset = 237;
1913 constexpr BlockLength length = 20;
1914
1915 return fixedStr<length>(value, offset);
1916 }
1917
1919 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1920 bool notionalCurrency(StrRef& value) const
1921 noexcept
1922 {
1923 constexpr BlockLength offset = 257;
1924 constexpr BlockLength length = 3;
1925
1926 return fixedStr<length>(value, offset);
1927 }
1928
1930 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1931 bool miFIdClearingFlag(StrRef& value) const
1932 noexcept
1933 {
1934 constexpr BlockLength offset = 260;
1935 constexpr BlockLength length = 5;
1936
1937 return fixedStr<length>(value, offset);
1938 }
1939
1941 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1942 bool
1943 mMTMarketMechanism(
1944 MmtMarketMechanism::Enum& value) const
1945 noexcept
1946 {
1947 constexpr BlockLength offset = 265;
1948
1949 return enumeration<MmtMarketMechanism>(value, offset, NullUInt8());
1950 }
1951
1953 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1954 bool
1955 mMTTradingMode(
1956 MmtTradingMode::Enum& value) const
1957 noexcept
1958 {
1959 constexpr BlockLength offset = 266;
1960
1961 return enumeration<MmtTradingMode>(value, offset, NullChar());
1962 }
1963
1965 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1966 bool mMTTransactionCategory(StrRef& value) const
1967 noexcept
1968 {
1969 constexpr BlockLength offset = 267;
1970 constexpr BlockLength length = 4;
1971
1972 return fixedStr<length>(value, offset);
1973 }
1974
1976 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1977 bool mMTNegotiationIndicator(StrRef& value) const
1978 noexcept
1979 {
1980 constexpr BlockLength offset = 271;
1981 constexpr BlockLength length = 4;
1982
1983 return fixedStr<length>(value, offset);
1984 }
1985
1987 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1988 bool mMTAgencyCrossTradeIndicator(StrRef& value) const
1989 noexcept
1990 {
1991 constexpr BlockLength offset = 275;
1992 constexpr BlockLength length = 4;
1993
1994 return fixedStr<length>(value, offset);
1995 }
1996
1998 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1999 bool mMTModificationIndicator(StrRef& value) const
2000 noexcept
2001 {
2002 constexpr BlockLength offset = 279;
2003 constexpr BlockLength length = 4;
2004
2005 return fixedStr<length>(value, offset);
2006 }
2007
2009 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2010 bool mMTBenchmarkIndicator(StrRef& value) const
2011 noexcept
2012 {
2013 constexpr BlockLength offset = 283;
2014 constexpr BlockLength length = 4;
2015
2016 return fixedStr<length>(value, offset);
2017 }
2018
2020 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2021 bool mMTSpecialDividendIndicator(StrRef& value) const
2022 noexcept
2023 {
2024 constexpr BlockLength offset = 287;
2025 constexpr BlockLength length = 4;
2026
2027 return fixedStr<length>(value, offset);
2028 }
2029
2031 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2032 bool
2033 mMTOffBookAutomatedIndicator(
2034 MmtOffBookAutomatedIndicator::Enum& value) const
2035 noexcept
2036 {
2037 constexpr BlockLength offset = 291;
2038
2039 return enumeration<MmtOffBookAutomatedIndicator>(value, offset, NullChar());
2040 }
2041
2043 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2044 bool mMTContributiontoPrice(StrRef& value) const
2045 noexcept
2046 {
2047 constexpr BlockLength offset = 292;
2048 constexpr BlockLength length = 4;
2049
2050 return fixedStr<length>(value, offset);
2051 }
2052
2054 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2055 bool mMTAlgorithmicIndicator(StrRef& value) const
2056 noexcept
2057 {
2058 constexpr BlockLength offset = 296;
2059 constexpr BlockLength length = 4;
2060
2061 return fixedStr<length>(value, offset);
2062 }
2063
2065 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2066 bool mMTPublicationMode(StrRef& value) const
2067 noexcept
2068 {
2069 constexpr BlockLength offset = 300;
2070 constexpr BlockLength length = 4;
2071
2072 return fixedStr<length>(value, offset);
2073 }
2074
2076 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2077 bool mMTPostTradeDeferral(StrRef& value) const
2078 noexcept
2079 {
2080 constexpr BlockLength offset = 304;
2081 constexpr BlockLength length = 4;
2082
2083 return fixedStr<length>(value, offset);
2084 }
2085
2087 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2088 bool mMTDuplicativeIndicator(StrRef& value) const
2089 noexcept
2090 {
2091 constexpr BlockLength offset = 308;
2092 constexpr BlockLength length = 4;
2093
2094 return fixedStr<length>(value, offset);
2095 }
2096
2098 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2099 TradeQualifier tradeQualifier() const
2100 noexcept
2101 {
2102 constexpr BlockLength offset = 312;
2103
2104 return ordinary<TradeQualifier>(offset);
2105 }
2106
2108 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2109 bool
2110 transactionType(
2111 TransactionType::Enum& value) const
2112 noexcept
2113 {
2114 constexpr BlockLength offset = 313;
2115
2116 return enumeration<TransactionType>(value, offset, NullUInt8());
2117 }
2118
2120 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2121 bool
2122 effectiveDateIndicator(
2123 EffectiveDateIndicator::Enum& value) const
2124 noexcept
2125 {
2126 constexpr BlockLength offset = 314;
2127
2128 return enumeration<EffectiveDateIndicator>(value, offset, NullUInt8());
2129 }
2130
2132 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2133 bool
2134 blockTradeCode(
2135 BlockTradeCode::Enum& value) const
2136 noexcept
2137 {
2138 constexpr BlockLength offset = 315;
2139
2140 return enumeration<BlockTradeCode>(value, offset, NullChar());
2141 }
2142
2144 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2145 bool tradeReference(StrRef& value) const
2146 noexcept
2147 {
2148 constexpr BlockLength offset = 316;
2149 constexpr BlockLength length = 30;
2150
2151 return fixedStr<length>(value, offset);
2152 }
2153
2155 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2156 bool originalReportTimestamp(Uint64& value) const
2157 noexcept
2158 {
2159 constexpr BlockLength offset = 346;
2160
2161 return ordinary(value, offset, NullUint64());
2162 }
2163
2165 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2166 bool
2167 transparencyIndicator(
2168 TransparencyIndicator::Enum& value) const
2169 noexcept
2170 {
2171 constexpr BlockLength offset = 354;
2172
2173 return enumeration<TransparencyIndicator>(value, offset, NullUInt8());
2174 }
2175
2177 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2178 bool currencyCoefficient(Uint32& value) const
2179 noexcept
2180 {
2181 constexpr BlockLength offset = 355;
2182
2183 return ordinary(value, offset, NullUint32());
2184 }
2185
2187 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2188 bool priceMultiplier(Uint32& value) const
2189 noexcept
2190 {
2191 constexpr BlockLength offset = 359;
2192
2193 return ordinary(value, offset, NullUint32());
2194 }
2195
2197 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2198 bool priceMultiplierDecimals(UnsignedChar& value) const
2199 noexcept
2200 {
2201 constexpr BlockLength offset = 363;
2202
2203 return ordinary(value, offset, NullUnsignedChar());
2204 }
2205
2207 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2208 StrRef venue() const
2209 noexcept
2210 {
2211 constexpr BlockLength offset = 364;
2212 constexpr BlockLength length = 11;
2213
2214 return fixedStr<length>(offset);
2215 }
2216
2218 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2219 bool startTimeVwap(Uint32& value) const
2220 noexcept
2221 {
2222 constexpr BlockLength offset = 375;
2223
2224 return ordinary(value, offset, NullUint32());
2225 }
2226
2228 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2229 bool endTimeVwap(Uint32& value) const
2230 noexcept
2231 {
2232 constexpr BlockLength offset = 379;
2233
2234 return ordinary(value, offset, NullUint32());
2235 }
2236
2238 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2239 bool miFIdEmissionAllowanceType(StrRef& value) const
2240 noexcept
2241 {
2242 constexpr BlockLength offset = 383;
2243 constexpr BlockLength length = 4;
2244
2245 return fixedStr<length>(value, offset);
2246 }
2247
2249 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2250 bool marketOfReferenceMIC(StrRef& value) const
2251 noexcept
2252 {
2253 constexpr BlockLength offset = 387;
2254 constexpr BlockLength length = 4;
2255
2256 return fixedStr<length>(value, offset);
2257 }
2258
2260 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2261 bool evaluatedPrice(Int64& value) const
2262 noexcept
2263 {
2264 constexpr BlockLength offset = 391;
2265
2266 return ordinary(value, offset, NullInt64());
2267 }
2268
2270 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2271 bool
2272 messagePriceNotation(
2273 MessagePriceNotation::Enum& value) const
2274 noexcept
2275 {
2276 constexpr BlockLength offset = 399;
2277
2278 return enumeration<MessagePriceNotation>(value, offset, NullUInt8());
2279 }
2280
2282 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2283 bool settlementDate(Uint16& value) const
2284 noexcept
2285 {
2286 constexpr BlockLength offset = 400;
2287
2288 return ordinary(value, offset, NullUint16());
2289 }
2290
2292 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2293 bool repoSettlementDate(Uint16& value) const
2294 noexcept
2295 {
2296 constexpr BlockLength offset = 402;
2297
2298 return ordinary(value, offset, NullUint16());
2299 }
2300
2302 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2303 bool tradeUniqueIdentifier(StrRef& value) const
2304 noexcept
2305 {
2306 constexpr BlockLength offset = 404;
2307 constexpr BlockLength length = 16;
2308 constexpr SchemaVersion since = 316;
2309
2310 return fixedStr<length>(value, offset, since);
2311 }
2312
2314 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2315 bool missingPrice(StrRef& value) const
2316 noexcept
2317 {
2318 constexpr BlockLength offset = 420;
2319 constexpr BlockLength length = 4;
2320 constexpr SchemaVersion since = 334;
2321
2322 return fixedStr<length>(value, offset, since);
2323 }
2324
2326 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2327 bool mMTPreTradeTransparencyWaiverRelatedtoSizeandScale(StrRef& value) const
2328 noexcept
2329 {
2330 constexpr BlockLength offset = 424;
2331 constexpr BlockLength length = 4;
2332 constexpr SchemaVersion since = 334;
2333
2334 return fixedStr<length>(value, offset, since);
2335 }
2336
2338 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2339 bool mMTPortfolioTransactionIndicator(StrRef& value) const
2340 noexcept
2341 {
2342 constexpr BlockLength offset = 428;
2343 constexpr BlockLength length = 4;
2344 constexpr SchemaVersion since = 334;
2345
2346 return fixedStr<length>(value, offset, since);
2347 }
2348
2350 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2351 bool mMTContingentTransactionIndicator(StrRef& value) const
2352 noexcept
2353 {
2354 constexpr BlockLength offset = 432;
2355 constexpr BlockLength length = 4;
2356 constexpr SchemaVersion since = 334;
2357
2358 return fixedStr<length>(value, offset, since);
2359 }
2360
2362 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2363 bool mMTPublicationModeIlliquid(StrRef& value) const
2364 noexcept
2365 {
2366 constexpr BlockLength offset = 436;
2367 constexpr BlockLength length = 4;
2368 constexpr SchemaVersion since = 334;
2369
2370 return fixedStr<length>(value, offset, since);
2371 }
2372
2374 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2375 bool mMTPublicationModeSizeSpecific(StrRef& value) const
2376 noexcept
2377 {
2378 constexpr BlockLength offset = 440;
2379 constexpr BlockLength length = 4;
2380 constexpr SchemaVersion since = 334;
2381
2382 return fixedStr<length>(value, offset, since);
2383 }
2384
2386 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2387 bool venueofPublication(StrRef& value) const
2388 noexcept
2389 {
2390 constexpr BlockLength offset = 444;
2391 constexpr BlockLength length = 4;
2392 constexpr SchemaVersion since = 353;
2393
2394 return fixedStr<length>(value, offset, since);
2395 }
2396
2398 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2399 bool postTradeDeferralFlags(StrRef& value) const
2400 noexcept
2401 {
2402 constexpr BlockLength offset = 448;
2403 constexpr BlockLength length = 4;
2404 constexpr SchemaVersion since = 353;
2405
2406 return fixedStr<length>(value, offset, since);
2407 }
2408
2410 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2411 NotUsedGroup1 notUsedGroup1() const
2412 noexcept
2413 {
2414 return getGroup<NotUsedGroup1>(
2415 NotUsedGroup1Access(),
2416 *this);
2417 }
2418
2420 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2421 constexpr
2422 static BlockLength minimalBlockLength(SchemaVersion version)
2423 noexcept
2424 {
2425 return
2426 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2427 (version >= 353)
2428 ? 452
2429 : (version >= 334)
2430 ? 444
2431 : (version >= 316)
2432 ? 420
2433 : 404;
2434 }
2435
2437 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2438 constexpr
2439 static BlockLength blockLength(SchemaVersion version)
2440 noexcept
2441 {
2442 return
2443 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2444 minimalBlockLength(version);
2445 }
2446
2448 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2449 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2450 constexpr
2451 static
2452 MessageSize
2453 getMinimalVariableFieldsSize(
2454 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
2455 {
2456 return
2457 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2458 static_cast<MessageSize>(NotUsedGroup1::EmptySize);
2459 }
2460
2462 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2463 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2464 constexpr
2465 static StrRef className()
2466 noexcept
2467 {
2468 return constructStrRef("FullTradeInformation");
2469 }
2470
2472 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2473 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2474 constexpr
2475 static StrRef fixType()
2476 noexcept
2477 {
2478 return constructStrRef("FullTradeInformation");
2479 }
2480
2482 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2483 std::string toString() const;
2484
2485private:
2486 void checkLength(
2487 EncodedLength length, SchemaVersion version) const
2488 {
2489 const EncodedLength minimalRequiredLength =
2490 minimalBlockLength(version) +
2491 MessageHeader::Size +
2492 getMinimalVariableFieldsSize(version);
2493
2494 checkBinaryLength(
2495 *this, length, minimalRequiredLength);
2496 }
2497
2499 void checkVarLenFields() const
2500 {
2501 groups().
2502 checkTail<NotUsedGroup1>();
2503 }
2504
2505 void checkCompatibility() const
2506 {
2507 assert(TemplateId == templateId());
2508
2509 checkSchema<Schema>(schemaId(), version());
2510 checkLength(bufferSize(), version());
2511 checkVarLenFields();
2512 }
2513
2515 struct NotUsedGroup1Access
2516 {
2517 NotUsedGroup1
2518 operator()(
2519 const FullTradeInformation& obj) const
2520 noexcept
2521 {
2522 return obj.
2523 groups().
2524 head<NotUsedGroup1>();
2525 }
2526 };
2527};
2528
2530ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
2531MarketStatusChange
2532: SbeMessage
2533{
2535 typedef SchemaTraits Schema;
2536
2538 enum { TemplateId = 1005 };
2539
2542 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
2543 MarketStatesEntry : SbeGroupEntry
2544 <
2545 GroupSizeEncoding::BlockLength
2546 >
2547 {
2549 typedef
2550 SbeGroupEntry
2551 <
2552 GroupSizeEncoding::BlockLength
2553 >
2554 Base;
2555
2558 MarketStatesEntry(
2559 const void* data,
2560 EncodedLength length,
2561 SchemaVersion version)
2562 : Base(data, numericCast<Base::BlockLength>(length), version)
2563 {
2564 assert(version >= Schema::MinimalVersion);
2565 assert(length >= minimalBlockLength(version));
2566 }
2567
2569 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2570 MarketDataChangeType::Enum
2571 changeType() const
2572 noexcept
2573 {
2574 constexpr BlockLength offset = 0;
2575
2576 return enumeration<MarketDataChangeType>(offset);
2577 }
2578
2580 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2581 bool symbolIndex(Uint32& value) const
2582 noexcept
2583 {
2584 constexpr BlockLength offset = 1;
2585
2586 return ordinary(value, offset, NullUint32());
2587 }
2588
2590 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2591 bool eventTime(Uint64& value) const
2592 noexcept
2593 {
2594 constexpr BlockLength offset = 5;
2595
2596 return ordinary(value, offset, NullUint64());
2597 }
2598
2600 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2601 bool bookState(BookState::Enum& value) const
2602 noexcept
2603 {
2604 constexpr BlockLength offset = 13;
2605
2606 return enumeration<BookState>(value, offset, NullUInt8());
2607 }
2608
2610 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2611 bool
2612 statusReason(
2613 StatusReason::Enum& value) const
2614 noexcept
2615 {
2616 constexpr BlockLength offset = 14;
2617
2618 return enumeration<StatusReason>(value, offset, NullUInt8());
2619 }
2620
2622 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2623 PhaseQualifier phaseQualifier() const
2624 noexcept
2625 {
2626 constexpr BlockLength offset = 15;
2627
2628 return ordinary<PhaseQualifier>(offset);
2629 }
2630
2632 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2633 bool
2634 tradingPeriod(
2635 TradingPeriod::Enum& value) const
2636 noexcept
2637 {
2638 constexpr BlockLength offset = 17;
2639
2640 return enumeration<TradingPeriod>(value, offset, NullUInt8());
2641 }
2642
2644 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2645 bool tradingSide(TradingSide::Enum& value) const
2646 noexcept
2647 {
2648 constexpr BlockLength offset = 18;
2649
2650 return enumeration<TradingSide>(value, offset, NullUInt8());
2651 }
2652
2654 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2655 bool priceLimits(PriceLimits::Enum& value) const
2656 noexcept
2657 {
2658 constexpr BlockLength offset = 19;
2659
2660 return enumeration<PriceLimits>(value, offset, NullUInt8());
2661 }
2662
2664 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2665 bool
2666 quoteSpreadMultiplier(
2667 QuoteSpreadMultiplier::Enum& value) const
2668 noexcept
2669 {
2670 constexpr BlockLength offset = 20;
2671
2672 return enumeration<QuoteSpreadMultiplier>(value, offset, NullUInt8());
2673 }
2674
2676 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2677 bool
2678 orderEntryQualifier(
2679 OrderEntryQualifier::Enum& value) const
2680 noexcept
2681 {
2682 constexpr BlockLength offset = 21;
2683
2684 return enumeration<OrderEntryQualifier>(value, offset, NullUInt8());
2685 }
2686
2688 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2689 Session::Enum session() const
2690 noexcept
2691 {
2692 constexpr BlockLength offset = 22;
2693
2694 return enumeration<Session>(offset);
2695 }
2696
2698 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2699 bool
2700 scheduledEvent(
2701 ScheduledEvent::Enum& value) const
2702 noexcept
2703 {
2704 constexpr BlockLength offset = 23;
2705
2706 return enumeration<ScheduledEvent>(value, offset, NullUInt8());
2707 }
2708
2710 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2711 bool scheduledEventTime(Uint64& value) const
2712 noexcept
2713 {
2714 constexpr BlockLength offset = 24;
2715
2716 return ordinary(value, offset, NullUint64());
2717 }
2718
2720 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2721 bool
2722 instrumentState(
2723 InstrumentState::Enum& value) const
2724 noexcept
2725 {
2726 constexpr BlockLength offset = 32;
2727
2728 return enumeration<InstrumentState>(value, offset, NullUInt8());
2729 }
2730
2733 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2734 constexpr
2735 static BlockLength blockLength(SchemaVersion version)
2736 noexcept
2737 {
2738 return
2739 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2740 minimalBlockLength(version);
2741 }
2742
2745 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2746 constexpr
2747 static
2748 BlockLength
2749 minimalBlockLength(
2750 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
2751 noexcept
2752 {
2753 return
2754 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2755 33;
2756 }
2757
2759 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2760 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2761 constexpr
2762 static StrRef className()
2763 noexcept
2764 {
2765 return constructStrRef("MarketStatusChange.MarketStatesEntry");
2766 }
2767 };
2768
2770 typedef
2771 SbeGroup<MarketStatesEntry, GroupSizeEncoding, MessageSize>
2772 MarketStates;
2773
2775 MarketStatusChange() =default;
2776
2778 MarketStatusChange(
2779 const void* data,
2780 EncodedLength length)
2781 : SbeMessage(data, length)
2782 {
2783 checkCompatibility();
2784 }
2785
2787 explicit
2788 MarketStatusChange(
2789 const SbeMessage& message)
2790 : SbeMessage(message)
2791 {
2792 assert(message.valid());
2793
2794 checkCompatibility();
2795 }
2796
2798 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2799 bool seqNum(Uint64& value) const
2800 noexcept
2801 {
2802 constexpr BlockLength offset = 0;
2803
2804 return ordinary(value, offset, NullUint64());
2805 }
2806
2808 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2809 bool rebroadcastIndicator(UnsignedChar& value) const
2810 noexcept
2811 {
2812 constexpr BlockLength offset = 8;
2813
2814 return ordinary(value, offset, NullUnsignedChar());
2815 }
2816
2818 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2819 Emm::Enum eMM() const
2820 noexcept
2821 {
2822 constexpr BlockLength offset = 9;
2823
2824 return enumeration<Emm>(offset);
2825 }
2826
2828 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2829 MarketStates marketStates() const
2830 noexcept
2831 {
2832 return getGroup<MarketStates>(
2833 MarketStatesAccess(),
2834 *this);
2835 }
2836
2838 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2839 constexpr
2840 static
2841 BlockLength
2842 minimalBlockLength(
2843 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
2844 noexcept
2845 {
2846 return
2847 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2848 10;
2849 }
2850
2852 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2853 constexpr
2854 static BlockLength blockLength(SchemaVersion version)
2855 noexcept
2856 {
2857 return
2858 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2859 minimalBlockLength(version);
2860 }
2861
2863 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2864 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2865 constexpr
2866 static
2867 MessageSize
2868 getMinimalVariableFieldsSize(
2869 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
2870 {
2871 return
2872 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2873 static_cast<MessageSize>(MarketStates::EmptySize);
2874 }
2875
2877 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2878 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2879 constexpr
2880 static StrRef className()
2881 noexcept
2882 {
2883 return constructStrRef("MarketStatusChange");
2884 }
2885
2887 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2888 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2889 constexpr
2890 static StrRef fixType()
2891 noexcept
2892 {
2893 return constructStrRef("MarketStatusChange");
2894 }
2895
2897 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2898 std::string toString() const;
2899
2900private:
2901 void checkLength(
2902 EncodedLength length, SchemaVersion version) const
2903 {
2904 const EncodedLength minimalRequiredLength =
2905 minimalBlockLength(version) +
2906 MessageHeader::Size +
2907 getMinimalVariableFieldsSize(version);
2908
2909 checkBinaryLength(
2910 *this, length, minimalRequiredLength);
2911 }
2912
2914 void checkVarLenFields() const
2915 {
2916 groups().
2917 checkTail<MarketStates>();
2918 }
2919
2920 void checkCompatibility() const
2921 {
2922 assert(TemplateId == templateId());
2923
2924 checkSchema<Schema>(schemaId(), version());
2925 checkLength(bufferSize(), version());
2926 checkVarLenFields();
2927 }
2928
2930 struct MarketStatesAccess
2931 {
2932 MarketStates
2933 operator()(
2934 const MarketStatusChange& obj) const
2935 noexcept
2936 {
2937 return obj.
2938 groups().
2939 head<MarketStates>();
2940 }
2941 };
2942};
2943
2945ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
2946Timetable
2947: SbeMessage
2948{
2950 typedef SchemaTraits Schema;
2951
2953 enum { TemplateId = 1006 };
2954
2957 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
2958 TimetablesEntry : SbeGroupEntry
2959 <
2960 GroupSizeEncoding::BlockLength
2961 >
2962 {
2964 typedef
2965 SbeGroupEntry
2966 <
2967 GroupSizeEncoding::BlockLength
2968 >
2969 Base;
2970
2973 TimetablesEntry(
2974 const void* data,
2975 EncodedLength length,
2976 SchemaVersion version)
2977 : Base(data, numericCast<Base::BlockLength>(length), version)
2978 {
2979 assert(version >= Schema::MinimalVersion);
2980 assert(length >= minimalBlockLength(version));
2981 }
2982
2984 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2985 bool phaseTime(Uint64& value) const
2986 noexcept
2987 {
2988 constexpr BlockLength offset = 0;
2989
2990 return ordinary(value, offset, NullUint64());
2991 }
2992
2994 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2995 PhaseId::Enum phaseId() const
2996 noexcept
2997 {
2998 constexpr BlockLength offset = 8;
2999
3000 return enumeration<PhaseId>(offset);
3001 }
3002
3004 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3005 PhaseQualifier phaseQualifier() const
3006 noexcept
3007 {
3008 constexpr BlockLength offset = 9;
3009
3010 return ordinary<PhaseQualifier>(offset);
3011 }
3012
3014 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3015 TradingPeriod::Enum tradingPeriod() const
3016 noexcept
3017 {
3018 constexpr BlockLength offset = 11;
3019
3020 return enumeration<TradingPeriod>(offset);
3021 }
3022
3024 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3025 bool
3026 orderEntryQualifier(
3027 OrderEntryQualifier::Enum& value) const
3028 noexcept
3029 {
3030 constexpr BlockLength offset = 12;
3031
3032 return enumeration<OrderEntryQualifier>(value, offset, NullUInt8());
3033 }
3034
3036 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3037 Session::Enum session() const
3038 noexcept
3039 {
3040 constexpr BlockLength offset = 13;
3041
3042 return enumeration<Session>(offset);
3043 }
3044
3046 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3047 bool
3048 scheduledEvent(
3049 ScheduledEvent::Enum& value) const
3050 noexcept
3051 {
3052 constexpr BlockLength offset = 14;
3053
3054 return enumeration<ScheduledEvent>(value, offset, NullUInt8());
3055 }
3056
3059 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3060 constexpr
3061 static BlockLength blockLength(SchemaVersion version)
3062 noexcept
3063 {
3064 return
3065 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3066 minimalBlockLength(version);
3067 }
3068
3071 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3072 constexpr
3073 static
3074 BlockLength
3075 minimalBlockLength(
3076 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
3077 noexcept
3078 {
3079 return
3080 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3081 15;
3082 }
3083
3085 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3086 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3087 constexpr
3088 static StrRef className()
3089 noexcept
3090 {
3091 return constructStrRef("Timetable.TimetablesEntry");
3092 }
3093 };
3094
3096 typedef
3097 SbeGroup<TimetablesEntry, GroupSizeEncoding, MessageSize>
3098 Timetables;
3099
3101 Timetable() =default;
3102
3104 Timetable(
3105 const void* data,
3106 EncodedLength length)
3107 : SbeMessage(data, length)
3108 {
3109 checkCompatibility();
3110 }
3111
3113 explicit
3114 Timetable(
3115 const SbeMessage& message)
3116 : SbeMessage(message)
3117 {
3118 assert(message.valid());
3119
3120 checkCompatibility();
3121 }
3122
3124 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3125 bool seqNum(Uint64& value) const
3126 noexcept
3127 {
3128 constexpr BlockLength offset = 0;
3129
3130 return ordinary(value, offset, NullUint64());
3131 }
3132
3134 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3135 bool rebroadcastIndicator(UnsignedChar& value) const
3136 noexcept
3137 {
3138 constexpr BlockLength offset = 8;
3139
3140 return ordinary(value, offset, NullUnsignedChar());
3141 }
3142
3144 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3145 bool eMM(Emm::Enum& value) const
3146 noexcept
3147 {
3148 constexpr BlockLength offset = 9;
3149
3150 return enumeration<Emm>(value, offset, NullUInt8());
3151 }
3152
3154 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3155 bool patternId(Uint16& value) const
3156 noexcept
3157 {
3158 constexpr BlockLength offset = 10;
3159
3160 return ordinary(value, offset, NullUint16());
3161 }
3162
3164 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3165 bool symbolIndex(Uint32& value) const
3166 noexcept
3167 {
3168 constexpr BlockLength offset = 12;
3169
3170 return ordinary(value, offset, NullUint32());
3171 }
3172
3174 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3175 Timetables timetables() const
3176 noexcept
3177 {
3178 return getGroup<Timetables>(
3179 TimetablesAccess(),
3180 *this);
3181 }
3182
3184 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3185 constexpr
3186 static
3187 BlockLength
3188 minimalBlockLength(
3189 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
3190 noexcept
3191 {
3192 return
3193 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3194 16;
3195 }
3196
3198 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3199 constexpr
3200 static BlockLength blockLength(SchemaVersion version)
3201 noexcept
3202 {
3203 return
3204 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3205 minimalBlockLength(version);
3206 }
3207
3209 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3210 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3211 constexpr
3212 static
3213 MessageSize
3214 getMinimalVariableFieldsSize(
3215 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
3216 {
3217 return
3218 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3219 static_cast<MessageSize>(Timetables::EmptySize);
3220 }
3221
3223 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3224 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3225 constexpr
3226 static StrRef className()
3227 noexcept
3228 {
3229 return constructStrRef("Timetable");
3230 }
3231
3233 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3234 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3235 constexpr
3236 static StrRef fixType()
3237 noexcept
3238 {
3239 return constructStrRef("Timetable");
3240 }
3241
3243 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3244 std::string toString() const;
3245
3246private:
3247 void checkLength(
3248 EncodedLength length, SchemaVersion version) const
3249 {
3250 const EncodedLength minimalRequiredLength =
3251 minimalBlockLength(version) +
3252 MessageHeader::Size +
3253 getMinimalVariableFieldsSize(version);
3254
3255 checkBinaryLength(
3256 *this, length, minimalRequiredLength);
3257 }
3258
3260 void checkVarLenFields() const
3261 {
3262 groups().
3263 checkTail<Timetables>();
3264 }
3265
3266 void checkCompatibility() const
3267 {
3268 assert(TemplateId == templateId());
3269
3270 checkSchema<Schema>(schemaId(), version());
3271 checkLength(bufferSize(), version());
3272 checkVarLenFields();
3273 }
3274
3276 struct TimetablesAccess
3277 {
3278 Timetables operator()(const Timetable& obj) const
3279 noexcept
3280 {
3281 return obj.
3282 groups().
3283 head<Timetables>();
3284 }
3285 };
3286};
3287
3289ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
3290StandingData
3291: SbeMessage
3292{
3294 typedef SchemaTraits Schema;
3295
3297 enum { TemplateId = 1007 };
3298
3301 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
3302 EmmPatternRepEntry : SbeGroupEntry
3303 <
3304 GroupSizeEncoding::BlockLength
3305 >
3306 {
3308 typedef
3309 SbeGroupEntry
3310 <
3311 GroupSizeEncoding::BlockLength
3312 >
3313 Base;
3314
3317 EmmPatternRepEntry(
3318 const void* data,
3319 EncodedLength length,
3320 SchemaVersion version)
3321 : Base(data, numericCast<Base::BlockLength>(length), version)
3322 {
3323 assert(version >= Schema::MinimalVersion);
3324 assert(length >= minimalBlockLength(version));
3325 }
3326
3328 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3329 Emm::Enum eMM() const
3330 noexcept
3331 {
3332 constexpr BlockLength offset = 0;
3333
3334 return enumeration<Emm>(offset);
3335 }
3336
3338 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3339 bool patternId(Uint16& value) const
3340 noexcept
3341 {
3342 constexpr BlockLength offset = 1;
3343
3344 return ordinary(value, offset, NullUint16());
3345 }
3346
3348 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3349 bool tickSizeIndexId(Uint16& value) const
3350 noexcept
3351 {
3352 constexpr BlockLength offset = 3;
3353
3354 return ordinary(value, offset, NullUint16());
3355 }
3356
3358 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3359 bool marketModel(MarketModel::Enum& value) const
3360 noexcept
3361 {
3362 constexpr BlockLength offset = 5;
3363
3364 return enumeration<MarketModel>(value, offset, NullUInt8());
3365 }
3366
3368 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3369 bool lotSize(Uint64& value) const
3370 noexcept
3371 {
3372 constexpr BlockLength offset = 6;
3373
3374 return ordinary(value, offset, NullUint64());
3375 }
3376
3378 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3379 bool
3380 instUnitExp(
3381 InstrumentUnitExpression::Enum& value) const
3382 noexcept
3383 {
3384 constexpr BlockLength offset = 14;
3385
3386 return enumeration<InstrumentUnitExpression>(value, offset, NullUInt8());
3387 }
3388
3390 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3391 bool anonymous(Anonymous::Enum& value) const
3392 noexcept
3393 {
3394 constexpr BlockLength offset = 15;
3395
3396 return enumeration<Anonymous>(value, offset, NullUInt8());
3397 }
3398
3401 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3402 constexpr
3403 static BlockLength blockLength(SchemaVersion version)
3404 noexcept
3405 {
3406 return
3407 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3408 minimalBlockLength(version);
3409 }
3410
3413 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3414 constexpr
3415 static
3416 BlockLength
3417 minimalBlockLength(
3418 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
3419 noexcept
3420 {
3421 return
3422 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3423 16;
3424 }
3425
3427 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3428 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3429 constexpr
3430 static StrRef className()
3431 noexcept
3432 {
3433 return constructStrRef("StandingData.EmmPatternRepEntry");
3434 }
3435 };
3436
3438 typedef
3439 SbeGroup<EmmPatternRepEntry, GroupSizeEncoding, MessageSize>
3440 EmmPatternRep;
3441
3443 StandingData() =default;
3444
3446 StandingData(
3447 const void* data,
3448 EncodedLength length)
3449 : SbeMessage(data, length)
3450 {
3451 checkCompatibility();
3452 }
3453
3455 explicit
3456 StandingData(
3457 const SbeMessage& message)
3458 : SbeMessage(message)
3459 {
3460 assert(message.valid());
3461
3462 checkCompatibility();
3463 }
3464
3466 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3467 bool seqNum(Uint64& value) const
3468 noexcept
3469 {
3470 constexpr BlockLength offset = 0;
3471
3472 return ordinary(value, offset, NullUint64());
3473 }
3474
3476 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3477 bool rebroadcastIndicator(UnsignedChar& value) const
3478 noexcept
3479 {
3480 constexpr BlockLength offset = 8;
3481
3482 return ordinary(value, offset, NullUnsignedChar());
3483 }
3484
3486 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3487 bool symbolIndex(Uint32& value) const
3488 noexcept
3489 {
3490 constexpr BlockLength offset = 9;
3491
3492 return ordinary(value, offset, NullUint32());
3493 }
3494
3496 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3497 OptiqSegment::Enum optiqSegment() const
3498 noexcept
3499 {
3500 constexpr BlockLength offset = 13;
3501
3502 return enumeration<OptiqSegment>(offset);
3503 }
3504
3506 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3507 bool partitionId(Uint16& value) const
3508 noexcept
3509 {
3510 constexpr BlockLength offset = 14;
3511
3512 return ordinary(value, offset, NullUint16());
3513 }
3514
3516 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3517 bool fullInstrumentName(StrRef& value) const
3518 noexcept
3519 {
3520 constexpr BlockLength offset = 16;
3521 constexpr BlockLength length = 102;
3522
3523 return fixedStr<length>(value, offset);
3524 }
3525
3527 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3528 StrRef instrumentName() const
3529 noexcept
3530 {
3531 constexpr BlockLength offset = 118;
3532 constexpr BlockLength length = 18;
3533
3534 return fixedStr<length>(offset);
3535 }
3536
3538 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3539 bool instrumentTradingCode(StrRef& value) const
3540 noexcept
3541 {
3542 constexpr BlockLength offset = 136;
3543 constexpr BlockLength length = 15;
3544
3545 return fixedStr<length>(value, offset);
3546 }
3547
3549 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3550 StrRef instrumentGroupCode() const
3551 noexcept
3552 {
3553 constexpr BlockLength offset = 151;
3554 constexpr BlockLength length = 2;
3555
3556 return fixedStr<length>(offset);
3557 }
3558
3560 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3561 StrRef iSINCode() const
3562 noexcept
3563 {
3564 constexpr BlockLength offset = 153;
3565 constexpr BlockLength length = 12;
3566
3567 return fixedStr<length>(offset);
3568 }
3569
3571 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3572 bool priceDecimals(UnsignedChar& value) const
3573 noexcept
3574 {
3575 constexpr BlockLength offset = 165;
3576
3577 return ordinary(value, offset, NullUnsignedChar());
3578 }
3579
3581 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3582 bool quantityDecimals(UnsignedChar& value) const
3583 noexcept
3584 {
3585 constexpr BlockLength offset = 166;
3586
3587 return ordinary(value, offset, NullUnsignedChar());
3588 }
3589
3591 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3592 bool amountDecimals(UnsignedChar& value) const
3593 noexcept
3594 {
3595 constexpr BlockLength offset = 167;
3596
3597 return ordinary(value, offset, NullUnsignedChar());
3598 }
3599
3601 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3602 bool ratioDecimals(UnsignedChar& value) const
3603 noexcept
3604 {
3605 constexpr BlockLength offset = 168;
3606
3607 return ordinary(value, offset, NullUnsignedChar());
3608 }
3609
3611 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3612 StrRef cFI() const
3613 noexcept
3614 {
3615 constexpr BlockLength offset = 169;
3616 constexpr BlockLength length = 6;
3617
3618 return fixedStr<length>(offset);
3619 }
3620
3622 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3623 bool instrumentEventDate(Uint16& value) const
3624 noexcept
3625 {
3626 constexpr BlockLength offset = 175;
3627
3628 return ordinary(value, offset, NullUint16());
3629 }
3630
3632 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3633 bool strikePrice(Int64& value) const
3634 noexcept
3635 {
3636 constexpr BlockLength offset = 177;
3637
3638 return ordinary(value, offset, NullInt64());
3639 }
3640
3642 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3643 bool darkEligibility(UnsignedChar& value) const
3644 noexcept
3645 {
3646 constexpr BlockLength offset = 185;
3647
3648 return ordinary(value, offset, NullUnsignedChar());
3649 }
3650
3652 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3653 bool darkLISThreshold(Uint64& value) const
3654 noexcept
3655 {
3656 constexpr BlockLength offset = 186;
3657
3658 return ordinary(value, offset, NullUint64());
3659 }
3660
3662 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3663 bool darkMinQuantity(Uint32& value) const
3664 noexcept
3665 {
3666 constexpr BlockLength offset = 194;
3667
3668 return ordinary(value, offset, NullUint32());
3669 }
3670
3672 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3673 bool dateOfLastTrade(Uint16& value) const
3674 noexcept
3675 {
3676 constexpr BlockLength offset = 198;
3677
3678 return ordinary(value, offset, NullUint16());
3679 }
3680
3682 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3683 bool depositaryList(StrRef& value) const
3684 noexcept
3685 {
3686 constexpr BlockLength offset = 200;
3687 constexpr BlockLength length = 20;
3688
3689 return fixedStr<length>(value, offset);
3690 }
3691
3693 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3694 bool mainDepositary(StrRef& value) const
3695 noexcept
3696 {
3697 constexpr BlockLength offset = 220;
3698 constexpr BlockLength length = 5;
3699
3700 return fixedStr<length>(value, offset);
3701 }
3702
3704 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3705 bool firstSettlementDate(Uint16& value) const
3706 noexcept
3707 {
3708 constexpr BlockLength offset = 225;
3709
3710 return ordinary(value, offset, NullUint16());
3711 }
3712
3714 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3715 bool
3716 guaranteeIndicator(
3717 GuaranteeIndicator::Enum& value) const
3718 noexcept
3719 {
3720 constexpr BlockLength offset = 227;
3721
3722 return enumeration<GuaranteeIndicator>(value, offset, NullUInt8());
3723 }
3724
3726 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3727 bool iCB(StrRef& value) const
3728 noexcept
3729 {
3730 constexpr BlockLength offset = 228;
3731 constexpr BlockLength length = 16;
3732
3733 return fixedStr<length>(value, offset);
3734 }
3735
3737 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3738 bool issuingCountry(StrRef& value) const
3739 noexcept
3740 {
3741 constexpr BlockLength offset = 244;
3742 constexpr BlockLength length = 3;
3743
3744 return fixedStr<length>(value, offset);
3745 }
3746
3748 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3749 bool lastAdjustedClosingPrice(Int64& value) const
3750 noexcept
3751 {
3752 constexpr BlockLength offset = 247;
3753
3754 return ordinary(value, offset, NullInt64());
3755 }
3756
3758 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3759 bool lotSize(Uint64& value) const
3760 noexcept
3761 {
3762 constexpr BlockLength offset = 255;
3763
3764 return ordinary(value, offset, NullUint64());
3765 }
3766
3768 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3769 bool maturityDate(StrRef& value) const
3770 noexcept
3771 {
3772 constexpr BlockLength offset = 263;
3773 constexpr BlockLength length = 8;
3774
3775 return fixedStr<length>(value, offset);
3776 }
3777
3779 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3780 bool maximumDecimalsInQuantity(UnsignedChar& value) const
3781 noexcept
3782 {
3783 constexpr BlockLength offset = 271;
3784
3785 return ordinary(value, offset, NullUnsignedChar());
3786 }
3787
3789 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3790 StrRef mIC() const
3791 noexcept
3792 {
3793 constexpr BlockLength offset = 272;
3794 constexpr BlockLength length = 4;
3795
3796 return fixedStr<length>(offset);
3797 }
3798
3800 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3801 bool mICList(StrRef& value) const
3802 noexcept
3803 {
3804 constexpr BlockLength offset = 276;
3805 constexpr BlockLength length = 20;
3806
3807 return fixedStr<length>(value, offset);
3808 }
3809
3811 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3812 bool countryOfExchange(StrRef& value) const
3813 noexcept
3814 {
3815 constexpr BlockLength offset = 296;
3816 constexpr BlockLength length = 3;
3817
3818 return fixedStr<length>(value, offset);
3819 }
3820
3822 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3823 bool mnemonic(StrRef& value) const
3824 noexcept
3825 {
3826 constexpr BlockLength offset = 299;
3827 constexpr BlockLength length = 5;
3828
3829 return fixedStr<length>(value, offset);
3830 }
3831
3833 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3834 bool underlyingMIC(StrRef& value) const
3835 noexcept
3836 {
3837 constexpr BlockLength offset = 304;
3838 constexpr BlockLength length = 4;
3839
3840 return fixedStr<length>(value, offset);
3841 }
3842
3844 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3845 bool underlyingISINCode(StrRef& value) const
3846 noexcept
3847 {
3848 constexpr BlockLength offset = 308;
3849 constexpr BlockLength length = 12;
3850
3851 return fixedStr<length>(value, offset);
3852 }
3853
3855 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3856 bool tradingCurrency(StrRef& value) const
3857 noexcept
3858 {
3859 constexpr BlockLength offset = 320;
3860 constexpr BlockLength length = 3;
3861
3862 return fixedStr<length>(value, offset);
3863 }
3864
3866 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3867 bool currencyCoefficient(Uint32& value) const
3868 noexcept
3869 {
3870 constexpr BlockLength offset = 323;
3871
3872 return ordinary(value, offset, NullUint32());
3873 }
3874
3876 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3877 bool
3878 tradingCurrencyIndicator(
3879 TradingCurrencyIndicator::Enum& value) const
3880 noexcept
3881 {
3882 constexpr BlockLength offset = 327;
3883
3884 return enumeration<TradingCurrencyIndicator>(value, offset, NullUInt8());
3885 }
3886
3888 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3889 bool
3890 strikeCurrencyIndicator(
3891 StrikeCurrencyIndicator::Enum& value) const
3892 noexcept
3893 {
3894 constexpr BlockLength offset = 328;
3895
3896 return enumeration<StrikeCurrencyIndicator>(value, offset, NullUInt8());
3897 }
3898
3900 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3901 bool numberInstrumentCirculating(Uint64& value) const
3902 noexcept
3903 {
3904 constexpr BlockLength offset = 329;
3905
3906 return ordinary(value, offset, NullUint64());
3907 }
3908
3910 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3911 bool parValue(Uint64& value) const
3912 noexcept
3913 {
3914 constexpr BlockLength offset = 337;
3915
3916 return ordinary(value, offset, NullUint64());
3917 }
3918
3920 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3921 bool quantityNotation(StrRef& value) const
3922 noexcept
3923 {
3924 constexpr BlockLength offset = 345;
3925 constexpr BlockLength length = 3;
3926
3927 return fixedStr<length>(value, offset);
3928 }
3929
3931 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3932 bool
3933 instUnitExp(
3934 InstrumentUnitExpression::Enum& value) const
3935 noexcept
3936 {
3937 constexpr BlockLength offset = 348;
3938
3939 return enumeration<InstrumentUnitExpression>(value, offset, NullUInt8());
3940 }
3941
3943 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3944 bool settlementDelay(StrRef& value) const
3945 noexcept
3946 {
3947 constexpr BlockLength offset = 349;
3948 constexpr BlockLength length = 2;
3949
3950 return fixedStr<length>(value, offset);
3951 }
3952
3954 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3955 bool strikeCurrency(StrRef& value) const
3956 noexcept
3957 {
3958 constexpr BlockLength offset = 351;
3959 constexpr BlockLength length = 3;
3960
3961 return fixedStr<length>(value, offset);
3962 }
3963
3965 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3966 bool taxCode(TaxCode::Enum& value) const
3967 noexcept
3968 {
3969 constexpr BlockLength offset = 354;
3970
3971 return enumeration<TaxCode>(value, offset, NullUInt8());
3972 }
3973
3975 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3976 bool typeOfCorporateEvent(StrRef& value) const
3977 noexcept
3978 {
3979 constexpr BlockLength offset = 355;
3980 constexpr BlockLength length = 2;
3981
3982 return fixedStr<length>(value, offset);
3983 }
3984
3986 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3987 bool
3988 typeOfMarketAdmission(
3989 TypeOfMarketAdmission::Enum& value) const
3990 noexcept
3991 {
3992 constexpr BlockLength offset = 357;
3993
3994 return enumeration<TypeOfMarketAdmission>(value, offset, NullChar());
3995 }
3996
3998 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3999 bool
4000 repoIndicator(
4001 RepoIndicator::Enum& value) const
4002 noexcept
4003 {
4004 constexpr BlockLength offset = 358;
4005
4006 return enumeration<RepoIndicator>(value, offset, NullUInt8());
4007 }
4008
4010 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4011 bool issuePrice(Int64& value) const
4012 noexcept
4013 {
4014 constexpr BlockLength offset = 359;
4015
4016 return ordinary(value, offset, NullInt64());
4017 }
4018
4020 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4021 bool nominalCurrency(StrRef& value) const
4022 noexcept
4023 {
4024 constexpr BlockLength offset = 367;
4025 constexpr BlockLength length = 3;
4026
4027 return fixedStr<length>(value, offset);
4028 }
4029
4031 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4032 bool issuePriceDecimals(UnsignedChar& value) const
4033 noexcept
4034 {
4035 constexpr BlockLength offset = 370;
4036
4037 return ordinary(value, offset, NullUnsignedChar());
4038 }
4039
4041 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4042 bool strikePriceDecimals(UnsignedChar& value) const
4043 noexcept
4044 {
4045 constexpr BlockLength offset = 371;
4046
4047 return ordinary(value, offset, NullUnsignedChar());
4048 }
4049
4051 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4052 bool liquidInstrumentIndicator(UnsignedChar& value) const
4053 noexcept
4054 {
4055 constexpr BlockLength offset = 372;
4056
4057 return ordinary(value, offset, NullUnsignedChar());
4058 }
4059
4061 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4062 bool marketOfReferenceMIC(StrRef& value) const
4063 noexcept
4064 {
4065 constexpr BlockLength offset = 373;
4066 constexpr BlockLength length = 4;
4067
4068 return fixedStr<length>(value, offset);
4069 }
4070
4072 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4073 bool iCBCode(StrRef& value) const
4074 noexcept
4075 {
4076 constexpr BlockLength offset = 377;
4077 constexpr BlockLength length = 8;
4078
4079 return fixedStr<length>(value, offset);
4080 }
4081
4083 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4084 bool thresholdLISPostTrade60mn(Uint64& value) const
4085 noexcept
4086 {
4087 constexpr BlockLength offset = 385;
4088
4089 return ordinary(value, offset, NullUint64());
4090 }
4091
4093 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4094 bool thresholdLISPostTrade120mn(Uint64& value) const
4095 noexcept
4096 {
4097 constexpr BlockLength offset = 393;
4098
4099 return ordinary(value, offset, NullUint64());
4100 }
4101
4103 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4104 bool thresholdLISPostTradeEOD(Uint64& value) const
4105 noexcept
4106 {
4107 constexpr BlockLength offset = 401;
4108
4109 return ordinary(value, offset, NullUint64());
4110 }
4111
4113 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4114 bool longMnemonic(StrRef& value) const
4115 noexcept
4116 {
4117 constexpr BlockLength offset = 409;
4118 constexpr BlockLength length = 6;
4119 constexpr SchemaVersion since = 316;
4120
4121 return fixedStr<length>(value, offset, since);
4122 }
4123
4125 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4126 bool maxOrderAmountCall(Uint64& value) const
4127 noexcept
4128 {
4129 constexpr BlockLength offset = 415;
4130 constexpr SchemaVersion since = 318;
4131
4132 return ordinary(value, offset, NullUint64(), since);
4133 }
4134
4136 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4137 bool maxOrderAmountContinuous(Uint64& value) const
4138 noexcept
4139 {
4140 constexpr BlockLength offset = 423;
4141 constexpr SchemaVersion since = 318;
4142
4143 return ordinary(value, offset, NullUint64(), since);
4144 }
4145
4147 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4148 bool maxOrderQuantityCall(Uint64& value) const
4149 noexcept
4150 {
4151 constexpr BlockLength offset = 431;
4152 constexpr SchemaVersion since = 318;
4153
4154 return ordinary(value, offset, NullUint64(), since);
4155 }
4156
4158 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4159 bool maxOrderQuantityContinuous(Uint64& value) const
4160 noexcept
4161 {
4162 constexpr BlockLength offset = 439;
4163 constexpr SchemaVersion since = 318;
4164
4165 return ordinary(value, offset, NullUint64(), since);
4166 }
4167
4169 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4170 bool poolFactor(Uint32& value) const
4171 noexcept
4172 {
4173 constexpr BlockLength offset = 447;
4174 constexpr SchemaVersion since = 318;
4175
4176 return ordinary(value, offset, NullUint32(), since);
4177 }
4178
4180 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4181 EmmPatternRep emmPatternRep() const
4182 noexcept
4183 {
4184 return getGroup<EmmPatternRep>(
4185 EmmPatternRepAccess(),
4186 *this);
4187 }
4188
4190 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4191 constexpr
4192 static BlockLength minimalBlockLength(SchemaVersion version)
4193 noexcept
4194 {
4195 return
4196 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4197 (version >= 318)
4198 ? 451
4199 : (version >= 316)
4200 ? 415
4201 : 409;
4202 }
4203
4205 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4206 constexpr
4207 static BlockLength blockLength(SchemaVersion version)
4208 noexcept
4209 {
4210 return
4211 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4212 minimalBlockLength(version);
4213 }
4214
4216 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4217 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4218 constexpr
4219 static
4220 MessageSize
4221 getMinimalVariableFieldsSize(
4222 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4223 {
4224 return
4225 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4226 static_cast<MessageSize>(EmmPatternRep::EmptySize);
4227 }
4228
4230 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4231 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4232 constexpr
4233 static StrRef className()
4234 noexcept
4235 {
4236 return constructStrRef("StandingData");
4237 }
4238
4240 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4241 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4242 constexpr
4243 static StrRef fixType()
4244 noexcept
4245 {
4246 return constructStrRef("StandingData");
4247 }
4248
4250 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4251 std::string toString() const;
4252
4253private:
4254 void checkLength(
4255 EncodedLength length, SchemaVersion version) const
4256 {
4257 const EncodedLength minimalRequiredLength =
4258 minimalBlockLength(version) +
4259 MessageHeader::Size +
4260 getMinimalVariableFieldsSize(version);
4261
4262 checkBinaryLength(
4263 *this, length, minimalRequiredLength);
4264 }
4265
4267 void checkVarLenFields() const
4268 {
4269 groups().
4270 checkTail<EmmPatternRep>();
4271 }
4272
4273 void checkCompatibility() const
4274 {
4275 assert(TemplateId == templateId());
4276
4277 checkSchema<Schema>(schemaId(), version());
4278 checkLength(bufferSize(), version());
4279 checkVarLenFields();
4280 }
4281
4283 struct EmmPatternRepAccess
4284 {
4285 EmmPatternRep operator()(const StandingData& obj) const
4286 noexcept
4287 {
4288 return obj.
4289 groups().
4290 head<EmmPatternRep>();
4291 }
4292 };
4293};
4294
4296ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
4297RealTimeIndex
4298: SbeMessage
4299{
4301 typedef SchemaTraits Schema;
4302
4304 enum { TemplateId = 1008 };
4305
4307 RealTimeIndex() =default;
4308
4310 RealTimeIndex(
4311 const void* data,
4312 EncodedLength length)
4313 : SbeMessage(data, length)
4314 {
4315 checkCompatibility();
4316 }
4317
4319 explicit
4320 RealTimeIndex(
4321 const SbeMessage& message)
4322 : SbeMessage(message)
4323 {
4324 assert(message.valid());
4325
4326 checkCompatibility();
4327 }
4328
4330 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4331 bool seqNum(Uint64& value) const
4332 noexcept
4333 {
4334 constexpr BlockLength offset = 0;
4335
4336 return ordinary(value, offset, NullUint64());
4337 }
4338
4340 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4341 bool rebroadcastIndicator(UnsignedChar& value) const
4342 noexcept
4343 {
4344 constexpr BlockLength offset = 8;
4345
4346 return ordinary(value, offset, NullUnsignedChar());
4347 }
4348
4350 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4351 Emm::Enum eMM() const
4352 noexcept
4353 {
4354 constexpr BlockLength offset = 9;
4355
4356 return enumeration<Emm>(offset);
4357 }
4358
4360 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4361 bool eventTime(Uint64& value) const
4362 noexcept
4363 {
4364 constexpr BlockLength offset = 10;
4365
4366 return ordinary(value, offset, NullUint64());
4367 }
4368
4370 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4371 bool symbolIndex(Uint32& value) const
4372 noexcept
4373 {
4374 constexpr BlockLength offset = 18;
4375
4376 return ordinary(value, offset, NullUint32());
4377 }
4378
4380 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4381 bool indexLevel(Int64& value) const
4382 noexcept
4383 {
4384 constexpr BlockLength offset = 22;
4385
4386 return ordinary(value, offset, NullInt64());
4387 }
4388
4390 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4391 bool pctgOfCapitalization(Uint64& value) const
4392 noexcept
4393 {
4394 constexpr BlockLength offset = 30;
4395
4396 return ordinary(value, offset, NullUint64());
4397 }
4398
4400 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4401 bool prctVarfromPrevClose(Int64& value) const
4402 noexcept
4403 {
4404 constexpr BlockLength offset = 38;
4405
4406 return ordinary(value, offset, NullInt64());
4407 }
4408
4410 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4411 bool numTradedInstruments(Uint16& value) const
4412 noexcept
4413 {
4414 constexpr BlockLength offset = 46;
4415
4416 return ordinary(value, offset, NullUint16());
4417 }
4418
4420 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4421 IndexLevelType::Enum indexLevelType() const
4422 noexcept
4423 {
4424 constexpr BlockLength offset = 48;
4425
4426 return enumeration<IndexLevelType>(offset);
4427 }
4428
4430 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4431 IndexPriceCode::Enum indexPriceCode() const
4432 noexcept
4433 {
4434 constexpr BlockLength offset = 49;
4435
4436 return enumeration<IndexPriceCode>(offset);
4437 }
4438
4440 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4441 constexpr
4442 static
4443 BlockLength
4444 minimalBlockLength(
4445 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4446 noexcept
4447 {
4448 return
4449 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4450 50;
4451 }
4452
4454 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4455 constexpr
4456 static BlockLength blockLength(SchemaVersion version)
4457 noexcept
4458 {
4459 return
4460 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4461 minimalBlockLength(version);
4462 }
4463
4465 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4466 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4467 constexpr
4468 static
4469 MessageSize
4470 getMinimalVariableFieldsSize(
4471 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4472 {
4473 return
4474 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4475 0;
4476 }
4477
4479 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4480 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4481 constexpr
4482 static StrRef className()
4483 noexcept
4484 {
4485 return constructStrRef("RealTimeIndex");
4486 }
4487
4489 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4490 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4491 constexpr
4492 static StrRef fixType()
4493 noexcept
4494 {
4495 return constructStrRef("RealTimeIndex");
4496 }
4497
4499 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4500 std::string toString() const;
4501
4502private:
4503 void checkLength(
4504 EncodedLength length, SchemaVersion version) const
4505 {
4506 const EncodedLength minimalRequiredLength =
4507 minimalBlockLength(version) +
4508 MessageHeader::Size +
4509 getMinimalVariableFieldsSize(version);
4510
4511 checkBinaryLength(
4512 *this, length, minimalRequiredLength);
4513 }
4514
4515 void checkCompatibility() const
4516 {
4517 assert(TemplateId == templateId());
4518
4519 checkSchema<Schema>(schemaId(), version());
4520 checkLength(bufferSize(), version());
4521 }
4522};
4523
4525ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
4526Statistics
4527: SbeMessage
4528{
4530 typedef SchemaTraits Schema;
4531
4533 enum { TemplateId = 1009 };
4534
4537 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
4538 NewStatsEntry : SbeGroupEntry
4539 <
4540 GroupSizeEncoding::BlockLength
4541 >
4542 {
4544 typedef
4545 SbeGroupEntry
4546 <
4547 GroupSizeEncoding::BlockLength
4548 >
4549 Base;
4550
4553 NewStatsEntry(
4554 const void* data,
4555 EncodedLength length,
4556 SchemaVersion version)
4557 : Base(data, numericCast<Base::BlockLength>(length), version)
4558 {
4559 assert(version >= Schema::MinimalVersion);
4560 assert(length >= minimalBlockLength(version));
4561 }
4562
4564 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4565 StatsUpdateType::Enum statsUpdateType() const
4566 noexcept
4567 {
4568 constexpr BlockLength offset = 0;
4569
4570 return enumeration<StatsUpdateType>(offset);
4571 }
4572
4574 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4575 bool statsUpdateValue(Int64& value) const
4576 noexcept
4577 {
4578 constexpr BlockLength offset = 1;
4579
4580 return ordinary(value, offset, NullInt64());
4581 }
4582
4585 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4586 constexpr
4587 static BlockLength blockLength(SchemaVersion version)
4588 noexcept
4589 {
4590 return
4591 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4592 minimalBlockLength(version);
4593 }
4594
4597 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4598 constexpr
4599 static
4600 BlockLength
4601 minimalBlockLength(
4602 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4603 noexcept
4604 {
4605 return
4606 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4607 9;
4608 }
4609
4611 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4612 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4613 constexpr
4614 static StrRef className()
4615 noexcept
4616 {
4617 return constructStrRef("Statistics.NewStatsEntry");
4618 }
4619 };
4620
4622 typedef
4623 SbeGroup<NewStatsEntry, GroupSizeEncoding, MessageSize>
4624 NewStats;
4625
4627 Statistics() =default;
4628
4630 Statistics(
4631 const void* data,
4632 EncodedLength length)
4633 : SbeMessage(data, length)
4634 {
4635 checkCompatibility();
4636 }
4637
4639 explicit
4640 Statistics(
4641 const SbeMessage& message)
4642 : SbeMessage(message)
4643 {
4644 assert(message.valid());
4645
4646 checkCompatibility();
4647 }
4648
4650 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4651 bool seqNum(Uint64& value) const
4652 noexcept
4653 {
4654 constexpr BlockLength offset = 0;
4655
4656 return ordinary(value, offset, NullUint64());
4657 }
4658
4660 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4661 bool rebroadcastIndicator(UnsignedChar& value) const
4662 noexcept
4663 {
4664 constexpr BlockLength offset = 8;
4665
4666 return ordinary(value, offset, NullUnsignedChar());
4667 }
4668
4670 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4671 bool symbolIndex(Uint32& value) const
4672 noexcept
4673 {
4674 constexpr BlockLength offset = 9;
4675
4676 return ordinary(value, offset, NullUint32());
4677 }
4678
4680 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4681 NewStats newStats() const
4682 noexcept
4683 {
4684 return getGroup<NewStats>(NewStatsAccess(), *this);
4685 }
4686
4688 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4689 constexpr
4690 static
4691 BlockLength
4692 minimalBlockLength(
4693 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4694 noexcept
4695 {
4696 return
4697 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4698 13;
4699 }
4700
4702 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4703 constexpr
4704 static BlockLength blockLength(SchemaVersion version)
4705 noexcept
4706 {
4707 return
4708 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4709 minimalBlockLength(version);
4710 }
4711
4713 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4714 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4715 constexpr
4716 static
4717 MessageSize
4718 getMinimalVariableFieldsSize(
4719 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4720 {
4721 return
4722 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4723 static_cast<MessageSize>(NewStats::EmptySize);
4724 }
4725
4727 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4728 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4729 constexpr
4730 static StrRef className()
4731 noexcept
4732 {
4733 return constructStrRef("Statistics");
4734 }
4735
4737 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4738 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4739 constexpr
4740 static StrRef fixType()
4741 noexcept
4742 {
4743 return constructStrRef("Statistics");
4744 }
4745
4747 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4748 std::string toString() const;
4749
4750private:
4751 void checkLength(
4752 EncodedLength length, SchemaVersion version) const
4753 {
4754 const EncodedLength minimalRequiredLength =
4755 minimalBlockLength(version) +
4756 MessageHeader::Size +
4757 getMinimalVariableFieldsSize(version);
4758
4759 checkBinaryLength(
4760 *this, length, minimalRequiredLength);
4761 }
4762
4764 void checkVarLenFields() const
4765 {
4766 groups().
4767 checkTail<NewStats>();
4768 }
4769
4770 void checkCompatibility() const
4771 {
4772 assert(TemplateId == templateId());
4773
4774 checkSchema<Schema>(schemaId(), version());
4775 checkLength(bufferSize(), version());
4776 checkVarLenFields();
4777 }
4778
4780 struct NewStatsAccess
4781 {
4782 NewStats operator()(const Statistics& obj) const
4783 noexcept
4784 {
4785 return obj.
4786 groups().
4787 head<NewStats>();
4788 }
4789 };
4790};
4791
4793ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
4794IndexSummary
4795: SbeMessage
4796{
4798 typedef SchemaTraits Schema;
4799
4801 enum { TemplateId = 1011 };
4802
4804 IndexSummary() =default;
4805
4807 IndexSummary(
4808 const void* data,
4809 EncodedLength length)
4810 : SbeMessage(data, length)
4811 {
4812 checkCompatibility();
4813 }
4814
4816 explicit
4817 IndexSummary(
4818 const SbeMessage& message)
4819 : SbeMessage(message)
4820 {
4821 assert(message.valid());
4822
4823 checkCompatibility();
4824 }
4825
4827 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4828 bool seqNum(Uint64& value) const
4829 noexcept
4830 {
4831 constexpr BlockLength offset = 0;
4832
4833 return ordinary(value, offset, NullUint64());
4834 }
4835
4837 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4838 bool rebroadcastIndicator(UnsignedChar& value) const
4839 noexcept
4840 {
4841 constexpr BlockLength offset = 8;
4842
4843 return ordinary(value, offset, NullUnsignedChar());
4844 }
4845
4847 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4848 Emm::Enum eMM() const
4849 noexcept
4850 {
4851 constexpr BlockLength offset = 9;
4852
4853 return enumeration<Emm>(offset);
4854 }
4855
4857 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4858 bool eventTime(Uint64& value) const
4859 noexcept
4860 {
4861 constexpr BlockLength offset = 10;
4862
4863 return ordinary(value, offset, NullUint64());
4864 }
4865
4867 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4868 bool symbolIndex(Uint32& value) const
4869 noexcept
4870 {
4871 constexpr BlockLength offset = 18;
4872
4873 return ordinary(value, offset, NullUint32());
4874 }
4875
4877 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4878 bool openingLevel(Int64& value) const
4879 noexcept
4880 {
4881 constexpr BlockLength offset = 22;
4882
4883 return ordinary(value, offset, NullInt64());
4884 }
4885
4887 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4888 bool openingTime(Uint64& value) const
4889 noexcept
4890 {
4891 constexpr BlockLength offset = 30;
4892
4893 return ordinary(value, offset, NullUint64());
4894 }
4895
4897 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4898 bool confirmedReferenceLevel(Int64& value) const
4899 noexcept
4900 {
4901 constexpr BlockLength offset = 38;
4902
4903 return ordinary(value, offset, NullInt64());
4904 }
4905
4907 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4908 bool confirmedReferenceTime(Uint64& value) const
4909 noexcept
4910 {
4911 constexpr BlockLength offset = 46;
4912
4913 return ordinary(value, offset, NullUint64());
4914 }
4915
4917 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4918 bool closingReferenceLevel(Int64& value) const
4919 noexcept
4920 {
4921 constexpr BlockLength offset = 54;
4922
4923 return ordinary(value, offset, NullInt64());
4924 }
4925
4927 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4928 bool closingReferenceTime(Uint64& value) const
4929 noexcept
4930 {
4931 constexpr BlockLength offset = 62;
4932
4933 return ordinary(value, offset, NullUint64());
4934 }
4935
4937 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4938 bool prctVarfromPrevClose(Int64& value) const
4939 noexcept
4940 {
4941 constexpr BlockLength offset = 70;
4942
4943 return ordinary(value, offset, NullInt64());
4944 }
4945
4947 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4948 bool highLevel(Int64& value) const
4949 noexcept
4950 {
4951 constexpr BlockLength offset = 78;
4952
4953 return ordinary(value, offset, NullInt64());
4954 }
4955
4957 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4958 bool highTime(Uint64& value) const
4959 noexcept
4960 {
4961 constexpr BlockLength offset = 86;
4962
4963 return ordinary(value, offset, NullUint64());
4964 }
4965
4967 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4968 bool lowLevel(Int64& value) const
4969 noexcept
4970 {
4971 constexpr BlockLength offset = 94;
4972
4973 return ordinary(value, offset, NullInt64());
4974 }
4975
4977 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4978 bool lowTime(Uint64& value) const
4979 noexcept
4980 {
4981 constexpr BlockLength offset = 102;
4982
4983 return ordinary(value, offset, NullUint64());
4984 }
4985
4987 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4988 bool liquidationLevel(Int64& value) const
4989 noexcept
4990 {
4991 constexpr BlockLength offset = 110;
4992
4993 return ordinary(value, offset, NullInt64());
4994 }
4995
4997 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4998 bool liquidationTime(Uint64& value) const
4999 noexcept
5000 {
5001 constexpr BlockLength offset = 118;
5002
5003 return ordinary(value, offset, NullUint64());
5004 }
5005
5007 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5008 constexpr
5009 static
5010 BlockLength
5011 minimalBlockLength(
5012 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5013 noexcept
5014 {
5015 return
5016 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5017 126;
5018 }
5019
5021 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5022 constexpr
5023 static BlockLength blockLength(SchemaVersion version)
5024 noexcept
5025 {
5026 return
5027 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5028 minimalBlockLength(version);
5029 }
5030
5032 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5033 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5034 constexpr
5035 static
5036 MessageSize
5037 getMinimalVariableFieldsSize(
5038 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5039 {
5040 return
5041 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5042 0;
5043 }
5044
5046 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5047 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5048 constexpr
5049 static StrRef className()
5050 noexcept
5051 {
5052 return constructStrRef("IndexSummary");
5053 }
5054
5056 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5057 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5058 constexpr
5059 static StrRef fixType()
5060 noexcept
5061 {
5062 return constructStrRef("IndexSummary");
5063 }
5064
5066 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5067 std::string toString() const;
5068
5069private:
5070 void checkLength(
5071 EncodedLength length, SchemaVersion version) const
5072 {
5073 const EncodedLength minimalRequiredLength =
5074 minimalBlockLength(version) +
5075 MessageHeader::Size +
5076 getMinimalVariableFieldsSize(version);
5077
5078 checkBinaryLength(
5079 *this, length, minimalRequiredLength);
5080 }
5081
5082 void checkCompatibility() const
5083 {
5084 assert(TemplateId == templateId());
5085
5086 checkSchema<Schema>(schemaId(), version());
5087 checkLength(bufferSize(), version());
5088 }
5089};
5090
5092ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
5093StrategyStandingData
5094: SbeMessage
5095{
5097 typedef SchemaTraits Schema;
5098
5100 enum { TemplateId = 1012 };
5101
5104 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
5105 StrategyStandingDatarep1Entry : SbeGroupEntry
5106 <
5107 GroupSizeEncoding::BlockLength
5108 >
5109 {
5111 typedef
5112 SbeGroupEntry
5113 <
5114 GroupSizeEncoding::BlockLength
5115 >
5116 Base;
5117
5120 StrategyStandingDatarep1Entry(
5121 const void* data,
5122 EncodedLength length,
5123 SchemaVersion version)
5124 : Base(data, numericCast<Base::BlockLength>(length), version)
5125 {
5126 assert(version >= Schema::MinimalVersion);
5127 assert(length >= minimalBlockLength(version));
5128 }
5129
5131 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5132 bool legSymbolIndex(Uint32& value) const
5133 noexcept
5134 {
5135 constexpr BlockLength offset = 0;
5136
5137 return ordinary(value, offset, NullUint32());
5138 }
5139
5141 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5142 bool legPrice(Int64& value) const
5143 noexcept
5144 {
5145 constexpr BlockLength offset = 4;
5146
5147 return ordinary(value, offset, NullInt64());
5148 }
5149
5151 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5152 bool legRatio(Uint32& value) const
5153 noexcept
5154 {
5155 constexpr BlockLength offset = 12;
5156
5157 return ordinary(value, offset, NullUint32());
5158 }
5159
5161 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5162 LegBuyorSell::Enum legBuySell() const
5163 noexcept
5164 {
5165 constexpr BlockLength offset = 16;
5166
5167 return enumeration<LegBuyorSell>(offset);
5168 }
5169
5172 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5173 constexpr
5174 static BlockLength blockLength(SchemaVersion version)
5175 noexcept
5176 {
5177 return
5178 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5179 minimalBlockLength(version);
5180 }
5181
5184 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5185 constexpr
5186 static
5187 BlockLength
5188 minimalBlockLength(
5189 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5190 noexcept
5191 {
5192 return
5193 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5194 17;
5195 }
5196
5198 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5199 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5200 constexpr
5201 static StrRef className()
5202 noexcept
5203 {
5204 return constructStrRef("StrategyStandingData.StrategyStandingDatarep1Entry");
5205 }
5206 };
5207
5209 typedef
5210 SbeGroup<StrategyStandingDatarep1Entry, GroupSizeEncoding, MessageSize>
5211 StrategyStandingDatarep1;
5212
5214 StrategyStandingData() =default;
5215
5217 StrategyStandingData(
5218 const void* data,
5219 EncodedLength length)
5220 : SbeMessage(data, length)
5221 {
5222 checkCompatibility();
5223 }
5224
5226 explicit
5227 StrategyStandingData(
5228 const SbeMessage& message)
5229 : SbeMessage(message)
5230 {
5231 assert(message.valid());
5232
5233 checkCompatibility();
5234 }
5235
5237 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5238 bool seqNum(Uint64& value) const
5239 noexcept
5240 {
5241 constexpr BlockLength offset = 0;
5242
5243 return ordinary(value, offset, NullUint64());
5244 }
5245
5247 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5248 bool rebroadcastIndicator(UnsignedChar& value) const
5249 noexcept
5250 {
5251 constexpr BlockLength offset = 8;
5252
5253 return ordinary(value, offset, NullUnsignedChar());
5254 }
5255
5257 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5258 Emm::Enum eMM() const
5259 noexcept
5260 {
5261 constexpr BlockLength offset = 9;
5262
5263 return enumeration<Emm>(offset);
5264 }
5265
5267 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5268 bool symbolIndex(Uint32& value) const
5269 noexcept
5270 {
5271 constexpr BlockLength offset = 10;
5272
5273 return ordinary(value, offset, NullUint32());
5274 }
5275
5277 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5278 StrRef derivativesInstrumentTradingCode() const
5279 noexcept
5280 {
5281 constexpr BlockLength offset = 14;
5282 constexpr BlockLength length = 18;
5283
5284 return fixedStr<length>(offset);
5285 }
5286
5288 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5289 ExchangeCode::Enum exchangeCode() const
5290 noexcept
5291 {
5292 constexpr BlockLength offset = 32;
5293
5294 return enumeration<ExchangeCode>(offset);
5295 }
5296
5298 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5299 StrRef maturityDate() const
5300 noexcept
5301 {
5302 constexpr BlockLength offset = 33;
5303 constexpr BlockLength length = 8;
5304
5305 return fixedStr<length>(offset);
5306 }
5307
5309 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5310 StrategyCode::Enum strategyCode() const
5311 noexcept
5312 {
5313 constexpr BlockLength offset = 41;
5314
5315 return enumeration<StrategyCode>(offset);
5316 }
5317
5319 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5320 bool contractSymbolIndex(Uint32& value) const
5321 noexcept
5322 {
5323 constexpr BlockLength offset = 42;
5324
5325 return ordinary(value, offset, NullUint32());
5326 }
5327
5329 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5330 bool cFI(StrRef& value) const
5331 noexcept
5332 {
5333 constexpr BlockLength offset = 46;
5334 constexpr BlockLength length = 6;
5335
5336 return fixedStr<length>(value, offset);
5337 }
5338
5340 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5341 StrategyStandingDatarep1 strategyStandingDatarep1() const
5342 noexcept
5343 {
5344 return getGroup<StrategyStandingDatarep1>(
5345 StrategyStandingDatarep1Access(),
5346 *this);
5347 }
5348
5350 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5351 constexpr
5352 static
5353 BlockLength
5354 minimalBlockLength(
5355 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5356 noexcept
5357 {
5358 return
5359 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5360 52;
5361 }
5362
5364 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5365 constexpr
5366 static BlockLength blockLength(SchemaVersion version)
5367 noexcept
5368 {
5369 return
5370 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5371 minimalBlockLength(version);
5372 }
5373
5375 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5376 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5377 constexpr
5378 static
5379 MessageSize
5387
5389 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5390 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5391 constexpr
5392 static StrRef className()
5393 noexcept
5394 {
5395 return constructStrRef("StrategyStandingData");
5396 }
5397
5399 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5400 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5401 constexpr
5402 static StrRef fixType()
5403 noexcept
5404 {
5405 return constructStrRef("StrategyStandingData");
5406 }
5407
5409 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5410 std::string toString() const;
5411
5412private:
5413 void checkLength(
5414 EncodedLength length, SchemaVersion version) const
5415 {
5416 const EncodedLength minimalRequiredLength =
5417 minimalBlockLength(version) +
5418 MessageHeader::Size +
5419 getMinimalVariableFieldsSize(version);
5420
5421 checkBinaryLength(
5422 *this, length, minimalRequiredLength);
5423 }
5424
5426 void checkVarLenFields() const
5427 {
5428 groups().
5429 checkTail<StrategyStandingDatarep1>();
5430 }
5431
5432 void checkCompatibility() const
5433 {
5434 assert(TemplateId == templateId());
5435
5436 checkSchema<Schema>(schemaId(), version());
5437 checkLength(bufferSize(), version());
5438 checkVarLenFields();
5439 }
5440
5442 struct StrategyStandingDatarep1Access
5443 {
5444 StrategyStandingDatarep1
5445 operator()(
5446 const StrategyStandingData& obj) const
5447 noexcept
5448 {
5449 return obj.
5450 groups().
5451 head<StrategyStandingDatarep1>();
5452 }
5453 };
5454};
5455
5457ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
5458ContractStandingData
5459: SbeMessage
5460{
5462 typedef SchemaTraits Schema;
5463
5465 enum { TemplateId = 1013 };
5466
5469 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
5470 ContractEMMPropertiesEntry : SbeGroupEntry
5471 <
5472 GroupSizeEncoding::BlockLength
5473 >
5474 {
5476 typedef
5477 SbeGroupEntry
5478 <
5479 GroupSizeEncoding::BlockLength
5480 >
5481 Base;
5482
5485 ContractEMMPropertiesEntry(
5486 const void* data,
5487 EncodedLength length,
5488 SchemaVersion version)
5489 : Base(data, numericCast<Base::BlockLength>(length), version)
5490 {
5491 assert(version >= Schema::MinimalVersion);
5492 assert(length >= minimalBlockLength(version));
5493 }
5494
5496 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5497 bool eMM(Emm::Enum& value) const
5498 noexcept
5499 {
5500 constexpr BlockLength offset = 0;
5501
5502 return enumeration<Emm>(value, offset, NullUInt8());
5503 }
5504
5506 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5507 bool tickSizeIndexId(Uint16& value) const
5508 noexcept
5509 {
5510 constexpr BlockLength offset = 1;
5511
5512 return ordinary(value, offset, NullUint16());
5513 }
5514
5516 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5517 bool patternId(Uint16& value) const
5518 noexcept
5519 {
5520 constexpr BlockLength offset = 3;
5521
5522 return ordinary(value, offset, NullUint16());
5523 }
5524
5526 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5527 bool lotSize(Uint64& value) const
5528 noexcept
5529 {
5530 constexpr BlockLength offset = 5;
5531
5532 return ordinary(value, offset, NullUint64());
5533 }
5534
5536 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5537 bool
5538 strategyAuthorized(
5539 StrategyAuthorized& value) const
5540 noexcept
5541 {
5542 constexpr BlockLength offset = 13;
5543
5544 return ordinary(value, offset, NullUInt64());
5545 }
5546
5548 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5549 bool
5550 dynamicCollarLogic(
5551 DynamicCollarLogic::Enum& value) const
5552 noexcept
5553 {
5554 constexpr BlockLength offset = 21;
5555
5556 return enumeration<DynamicCollarLogic>(value, offset, NullUInt8());
5557 }
5558
5560 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5561 bool collarMaxUnhaltNb(UnsignedChar& value) const
5562 noexcept
5563 {
5564 constexpr BlockLength offset = 22;
5565
5566 return ordinary(value, offset, NullUnsignedChar());
5567 }
5568
5570 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5571 bool collarUnhaltDelay(Uint32& value) const
5572 noexcept
5573 {
5574 constexpr BlockLength offset = 23;
5575
5576 return ordinary(value, offset, NullUint32());
5577 }
5578
5581 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5582 constexpr
5583 static BlockLength blockLength(SchemaVersion version)
5584 noexcept
5585 {
5586 return
5587 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5588 minimalBlockLength(version);
5589 }
5590
5593 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5594 constexpr
5595 static
5596 BlockLength
5597 minimalBlockLength(
5598 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5599 noexcept
5600 {
5601 return
5602 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5603 27;
5604 }
5605
5607 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5608 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5609 constexpr
5610 static StrRef className()
5611 noexcept
5612 {
5613 return constructStrRef("ContractStandingData.ContractEMMPropertiesEntry");
5614 }
5615 };
5616
5618 typedef
5619 SbeGroup<ContractEMMPropertiesEntry, GroupSizeEncoding, MessageSize>
5620 ContractEMMProperties;
5621
5623 ContractStandingData() =default;
5624
5626 ContractStandingData(
5627 const void* data,
5628 EncodedLength length)
5629 : SbeMessage(data, length)
5630 {
5631 checkCompatibility();
5632 }
5633
5635 explicit
5636 ContractStandingData(
5637 const SbeMessage& message)
5638 : SbeMessage(message)
5639 {
5640 assert(message.valid());
5641
5642 checkCompatibility();
5643 }
5644
5646 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5647 bool seqNum(Uint64& value) const
5648 noexcept
5649 {
5650 constexpr BlockLength offset = 0;
5651
5652 return ordinary(value, offset, NullUint64());
5653 }
5654
5656 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5657 bool rebroadcastIndicator(UnsignedChar& value) const
5658 noexcept
5659 {
5660 constexpr BlockLength offset = 8;
5661
5662 return ordinary(value, offset, NullUnsignedChar());
5663 }
5664
5666 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5667 bool symbolIndex(Uint32& value) const
5668 noexcept
5669 {
5670 constexpr BlockLength offset = 9;
5671
5672 return ordinary(value, offset, NullUint32());
5673 }
5674
5676 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5677 OptiqSegment::Enum optiqSegment() const
5678 noexcept
5679 {
5680 constexpr BlockLength offset = 13;
5681
5682 return enumeration<OptiqSegment>(offset);
5683 }
5684
5686 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5687 bool partitionId(Uint16& value) const
5688 noexcept
5689 {
5690 constexpr BlockLength offset = 14;
5691
5692 return ordinary(value, offset, NullUint16());
5693 }
5694
5696 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5697 bool contractEventDate(Uint16& value) const
5698 noexcept
5699 {
5700 constexpr BlockLength offset = 16;
5701
5702 return ordinary(value, offset, NullUint16());
5703 }
5704
5706 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5707 ExchangeCode::Enum exchangeCode() const
5708 noexcept
5709 {
5710 constexpr BlockLength offset = 18;
5711
5712 return enumeration<ExchangeCode>(offset);
5713 }
5714
5716 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5717 bool
5718 exerStyle(
5719 ExerciseStyle::Enum& value) const
5720 noexcept
5721 {
5722 constexpr BlockLength offset = 19;
5723
5724 return enumeration<ExerciseStyle>(value, offset, NullUInt8());
5725 }
5726
5728 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5729 StrRef contractName() const
5730 noexcept
5731 {
5732 constexpr BlockLength offset = 20;
5733 constexpr BlockLength length = 60;
5734
5735 return fixedStr<length>(offset);
5736 }
5737
5739 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5740 bool
5741 contractType(
5742 ContractType::Enum& value) const
5743 noexcept
5744 {
5745 constexpr BlockLength offset = 80;
5746
5747 return enumeration<ContractType>(value, offset, NullChar());
5748 }
5749
5751 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5752 UnderlyingType::Enum underlyingType() const
5753 noexcept
5754 {
5755 constexpr BlockLength offset = 81;
5756
5757 return enumeration<UnderlyingType>(offset);
5758 }
5759
5761 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5762 bool priceDecimals(UnsignedChar& value) const
5763 noexcept
5764 {
5765 constexpr BlockLength offset = 82;
5766
5767 return ordinary(value, offset, NullUnsignedChar());
5768 }
5769
5771 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5772 bool quantityDecimals(UnsignedChar& value) const
5773 noexcept
5774 {
5775 constexpr BlockLength offset = 83;
5776
5777 return ordinary(value, offset, NullUnsignedChar());
5778 }
5779
5781 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5782 bool amountDecimals(UnsignedChar& value) const
5783 noexcept
5784 {
5785 constexpr BlockLength offset = 84;
5786
5787 return ordinary(value, offset, NullUnsignedChar());
5788 }
5789
5791 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5792 bool ratioDecimals(UnsignedChar& value) const
5793 noexcept
5794 {
5795 constexpr BlockLength offset = 85;
5796
5797 return ordinary(value, offset, NullUnsignedChar());
5798 }
5799
5801 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5802 bool mainDepositary(StrRef& value) const
5803 noexcept
5804 {
5805 constexpr BlockLength offset = 86;
5806 constexpr BlockLength length = 5;
5807
5808 return fixedStr<length>(value, offset);
5809 }
5810
5812 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5813 StrRef mIC() const
5814 noexcept
5815 {
5816 constexpr BlockLength offset = 91;
5817 constexpr BlockLength length = 4;
5818
5819 return fixedStr<length>(offset);
5820 }
5821
5823 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5824 StrRef countryOfExchange() const
5825 noexcept
5826 {
5827 constexpr BlockLength offset = 95;
5828 constexpr BlockLength length = 3;
5829
5830 return fixedStr<length>(offset);
5831 }
5832
5834 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5835 StrRef productCode() const
5836 noexcept
5837 {
5838 constexpr BlockLength offset = 98;
5839 constexpr BlockLength length = 4;
5840
5841 return fixedStr<length>(offset);
5842 }
5843
5845 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5846 bool underlyingMIC(StrRef& value) const
5847 noexcept
5848 {
5849 constexpr BlockLength offset = 102;
5850 constexpr BlockLength length = 4;
5851
5852 return fixedStr<length>(value, offset);
5853 }
5854
5856 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5857 bool underlyingISINCode(StrRef& value) const
5858 noexcept
5859 {
5860 constexpr BlockLength offset = 106;
5861 constexpr BlockLength length = 12;
5862
5863 return fixedStr<length>(value, offset);
5864 }
5865
5867 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5868 bool underlyingExpiry(Uint32& value) const
5869 noexcept
5870 {
5871 constexpr BlockLength offset = 118;
5872
5873 return ordinary(value, offset, NullUint32());
5874 }
5875
5877 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5878 OrderTypeRules orderTypeRules() const
5879 noexcept
5880 {
5881 constexpr BlockLength offset = 122;
5882
5883 return ordinary<OrderTypeRules>(offset);
5884 }
5885
5887 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5888 bool settlementMethod(Char& value) const
5889 noexcept
5890 {
5891 constexpr BlockLength offset = 124;
5892
5893 return ordinary(value, offset, NullChar());
5894 }
5895
5897 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5898 StrRef tradingCurrency() const
5899 noexcept
5900 {
5901 constexpr BlockLength offset = 125;
5902 constexpr BlockLength length = 3;
5903
5904 return fixedStr<length>(offset);
5905 }
5906
5908 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5909 bool strikePriceDecimalsRatio(UnsignedChar& value) const
5910 noexcept
5911 {
5912 constexpr BlockLength offset = 128;
5913
5914 return ordinary(value, offset, NullUnsignedChar());
5915 }
5916
5918 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5919 MmProtections mMProtections() const
5920 noexcept
5921 {
5922 constexpr BlockLength offset = 129;
5923
5924 return ordinary<MmProtections>(offset);
5925 }
5926
5928 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5929 ContractTradingType::Enum
5930 contractTradingType() const
5931 noexcept
5932 {
5933 constexpr BlockLength offset = 130;
5934
5935 return enumeration<ContractTradingType>(offset);
5936 }
5937
5939 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5940 bool
5941 instUnitExp(
5942 InstrumentUnitExpression::Enum& value) const
5943 noexcept
5944 {
5945 constexpr BlockLength offset = 131;
5946
5947 return enumeration<InstrumentUnitExpression>(value, offset, NullUInt8());
5948 }
5949
5951 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5952 bool
5953 underlyingSubtype(
5954 UnderlyingSubtype::Enum& value) const
5955 noexcept
5956 {
5957 constexpr BlockLength offset = 132;
5958
5959 return enumeration<UnderlyingSubtype>(value, offset, NullUInt8());
5960 }
5961
5963 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5964 bool motherStockISIN(StrRef& value) const
5965 noexcept
5966 {
5967 constexpr BlockLength offset = 133;
5968 constexpr BlockLength length = 12;
5969
5970 return fixedStr<length>(value, offset);
5971 }
5972
5974 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5975 bool settlementTickSize(Uint64& value) const
5976 noexcept
5977 {
5978 constexpr BlockLength offset = 145;
5979
5980 return ordinary(value, offset, NullUint64());
5981 }
5982
5984 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5985 bool eDSPTickSize(Uint64& value) const
5986 noexcept
5987 {
5988 constexpr BlockLength offset = 153;
5989
5990 return ordinary(value, offset, NullUint64());
5991 }
5992
5994 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5995 bool underlyingSymbolIndex(Uint32& value) const
5996 noexcept
5997 {
5998 constexpr BlockLength offset = 161;
5999
6000 return ordinary(value, offset, NullUint32());
6001 }
6002
6004 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6005 bool
6006 tradingPolicy(
6007 TradingPolicy::Enum& value) const
6008 noexcept
6009 {
6010 constexpr BlockLength offset = 165;
6011
6012 return enumeration<TradingPolicy>(value, offset, NullUInt8());
6013 }
6014
6016 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6017 bool referenceSpreadTableId(Uint16& value) const
6018 noexcept
6019 {
6020 constexpr BlockLength offset = 166;
6021
6022 return ordinary(value, offset, NullUint16());
6023 }
6024
6026 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6027 bool
6028 derivativesMarketModel(
6029 DerivativesMarketModel::Enum& value) const
6030 noexcept
6031 {
6032 constexpr BlockLength offset = 168;
6033
6034 return enumeration<DerivativesMarketModel>(value, offset, NullUInt8());
6035 }
6036
6038 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6039 bool tradingUnit(Uint64& value) const
6040 noexcept
6041 {
6042 constexpr BlockLength offset = 169;
6043
6044 return ordinary(value, offset, NullUint64());
6045 }
6046
6048 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6049 bool
6050 referencePriceOriginInOpeningCall(
6051 ReferencePriceOrigin::Enum& value) const
6052 noexcept
6053 {
6054 constexpr BlockLength offset = 177;
6055
6056 return enumeration<ReferencePriceOrigin>(value, offset, NullUInt8());
6057 }
6058
6060 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6061 bool
6062 referencePriceOriginInContinuous(
6063 ReferencePriceOrigin::Enum& value) const
6064 noexcept
6065 {
6066 constexpr BlockLength offset = 178;
6067
6068 return enumeration<ReferencePriceOrigin>(value, offset, NullUInt8());
6069 }
6070
6072 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6073 bool
6074 referencePriceOriginInTradingInterruption(
6075 ReferencePriceOrigin::Enum& value) const
6076 noexcept
6077 {
6078 constexpr BlockLength offset = 179;
6079
6080 return enumeration<ReferencePriceOrigin>(value, offset, NullUInt8());
6081 }
6082
6084 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6085 bool collarExpansionFactor(UnsignedChar& value) const
6086 noexcept
6087 {
6088 constexpr BlockLength offset = 180;
6089
6090 return ordinary(value, offset, NullUnsignedChar());
6091 }
6092
6094 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6095 bool mIFIdIILiquidFlag(UnsignedChar& value) const
6096 noexcept
6097 {
6098 constexpr BlockLength offset = 181;
6099
6100 return ordinary(value, offset, NullUnsignedChar());
6101 }
6102
6104 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6105 PricingAlgorithm::Enum pricingAlgorithm() const
6106 noexcept
6107 {
6108 constexpr BlockLength offset = 182;
6109
6110 return enumeration<PricingAlgorithm>(offset);
6111 }
6112
6114 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6115 bool lotMultiplier(Uint64& value) const
6116 noexcept
6117 {
6118 constexpr BlockLength offset = 183;
6119 constexpr SchemaVersion since = 327;
6120
6121 return ordinary(value, offset, NullUint64(), since);
6122 }
6123
6125 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6126 ContractEMMProperties contractEMMProperties() const
6127 noexcept
6128 {
6129 return getGroup<ContractEMMProperties>(
6130 ContractEMMPropertiesAccess(),
6131 *this);
6132 }
6133
6135 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6136 constexpr
6137 static BlockLength minimalBlockLength(SchemaVersion version)
6138 noexcept
6139 {
6140 return
6141 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6142 (version >= 327)
6143 ? 191
6144 : 183;
6145 }
6146
6148 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6149 constexpr
6150 static BlockLength blockLength(SchemaVersion version)
6151 noexcept
6152 {
6153 return
6154 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6155 minimalBlockLength(version);
6156 }
6157
6159 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6160 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6161 constexpr
6162 static
6163 MessageSize
6171
6173 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6174 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6175 constexpr
6176 static StrRef className()
6177 noexcept
6178 {
6179 return constructStrRef("ContractStandingData");
6180 }
6181
6183 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6184 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6185 constexpr
6186 static StrRef fixType()
6187 noexcept
6188 {
6189 return constructStrRef("ContractStandingData");
6190 }
6191
6193 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6194 std::string toString() const;
6195
6196private:
6197 void checkLength(
6198 EncodedLength length, SchemaVersion version) const
6199 {
6200 const EncodedLength minimalRequiredLength =
6201 minimalBlockLength(version) +
6202 MessageHeader::Size +
6203 getMinimalVariableFieldsSize(version);
6204
6205 checkBinaryLength(
6206 *this, length, minimalRequiredLength);
6207 }
6208
6210 void checkVarLenFields() const
6211 {
6212 groups().
6213 checkTail<ContractEMMProperties>();
6214 }
6215
6216 void checkCompatibility() const
6217 {
6218 assert(TemplateId == templateId());
6219
6220 checkSchema<Schema>(schemaId(), version());
6221 checkLength(bufferSize(), version());
6222 checkVarLenFields();
6223 }
6224
6226 struct ContractEMMPropertiesAccess
6227 {
6228 ContractEMMProperties
6229 operator()(
6230 const ContractStandingData& obj) const
6231 noexcept
6232 {
6233 return obj.
6234 groups().
6235 head<ContractEMMProperties>();
6236 }
6237 };
6238};
6239
6241ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
6242OutrightStandingData
6243: SbeMessage
6244{
6246 typedef SchemaTraits Schema;
6247
6249 enum { TemplateId = 1014 };
6250
6253 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
6254 OutrightRepEntry : SbeGroupEntry
6255 <
6256 GroupSizeEncoding::BlockLength
6257 >
6258 {
6260 typedef
6261 SbeGroupEntry
6262 <
6263 GroupSizeEncoding::BlockLength
6264 >
6265 Base;
6266
6269 OutrightRepEntry(
6270 const void* data,
6271 EncodedLength length,
6272 SchemaVersion version)
6273 : Base(data, numericCast<Base::BlockLength>(length), version)
6274 {
6275 assert(version >= Schema::MinimalVersion);
6276 assert(length >= minimalBlockLength(version));
6277 }
6278
6280 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6281 Emm::Enum eMM() const
6282 noexcept
6283 {
6284 constexpr BlockLength offset = 0;
6285
6286 return enumeration<Emm>(offset);
6287 }
6288
6291 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6292 constexpr
6293 static BlockLength blockLength(SchemaVersion version)
6294 noexcept
6295 {
6296 return
6297 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6298 minimalBlockLength(version);
6299 }
6300
6303 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6304 constexpr
6305 static
6306 BlockLength
6307 minimalBlockLength(
6308 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6309 noexcept
6310 {
6311 return
6312 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6313 1;
6314 }
6315
6317 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6318 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6319 constexpr
6320 static StrRef className()
6321 noexcept
6322 {
6323 return constructStrRef("OutrightStandingData.OutrightRepEntry");
6324 }
6325 };
6326
6328 typedef
6329 SbeGroup<OutrightRepEntry, GroupSizeEncoding, MessageSize>
6330 OutrightRep;
6331
6333 OutrightStandingData() =default;
6334
6336 OutrightStandingData(
6337 const void* data,
6338 EncodedLength length)
6339 : SbeMessage(data, length)
6340 {
6341 checkCompatibility();
6342 }
6343
6345 explicit
6346 OutrightStandingData(
6347 const SbeMessage& message)
6348 : SbeMessage(message)
6349 {
6350 assert(message.valid());
6351
6352 checkCompatibility();
6353 }
6354
6356 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6357 bool seqNum(Uint64& value) const
6358 noexcept
6359 {
6360 constexpr BlockLength offset = 0;
6361
6362 return ordinary(value, offset, NullUint64());
6363 }
6364
6366 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6367 bool rebroadcastIndicator(UnsignedChar& value) const
6368 noexcept
6369 {
6370 constexpr BlockLength offset = 8;
6371
6372 return ordinary(value, offset, NullUnsignedChar());
6373 }
6374
6376 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6377 bool symbolIndex(Uint32& value) const
6378 noexcept
6379 {
6380 constexpr BlockLength offset = 9;
6381
6382 return ordinary(value, offset, NullUint32());
6383 }
6384
6386 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6387 bool contractSymbolIndex(Uint32& value) const
6388 noexcept
6389 {
6390 constexpr BlockLength offset = 13;
6391
6392 return ordinary(value, offset, NullUint32());
6393 }
6394
6396 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6397 bool instrumentEventDate(Uint16& value) const
6398 noexcept
6399 {
6400 constexpr BlockLength offset = 17;
6401
6402 return ordinary(value, offset, NullUint16());
6403 }
6404
6406 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6407 StrRef iSINCode() const
6408 noexcept
6409 {
6410 constexpr BlockLength offset = 19;
6411 constexpr BlockLength length = 12;
6412
6413 return fixedStr<length>(offset);
6414 }
6415
6417 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6418 bool cFI(StrRef& value) const
6419 noexcept
6420 {
6421 constexpr BlockLength offset = 31;
6422 constexpr BlockLength length = 6;
6423
6424 return fixedStr<length>(value, offset);
6425 }
6426
6428 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6429 StrRef maturityDate() const
6430 noexcept
6431 {
6432 constexpr BlockLength offset = 37;
6433 constexpr BlockLength length = 8;
6434
6435 return fixedStr<length>(offset);
6436 }
6437
6439 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6440 bool lotSize(Uint64& value) const
6441 noexcept
6442 {
6443 constexpr BlockLength offset = 45;
6444
6445 return ordinary(value, offset, NullUint64());
6446 }
6447
6449 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6450 bool strikePrice(Int64& value) const
6451 noexcept
6452 {
6453 constexpr BlockLength offset = 53;
6454
6455 return ordinary(value, offset, NullInt64());
6456 }
6457
6459 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6460 bool lastTradingDate(Uint16& value) const
6461 noexcept
6462 {
6463 constexpr BlockLength offset = 61;
6464
6465 return ordinary(value, offset, NullUint16());
6466 }
6467
6469 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6470 bool daysToExpiry(Uint16& value) const
6471 noexcept
6472 {
6473 constexpr BlockLength offset = 63;
6474
6475 return ordinary(value, offset, NullUint16());
6476 }
6477
6479 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6480 bool derivativesInstrumentTradingCode(StrRef& value) const
6481 noexcept
6482 {
6483 constexpr BlockLength offset = 65;
6484 constexpr BlockLength length = 18;
6485
6486 return fixedStr<length>(value, offset);
6487 }
6488
6490 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6491 bool
6492 derivativesInstrumentType(
6493 DerivativesInstrumentType::Enum& value) const
6494 noexcept
6495 {
6496 constexpr BlockLength offset = 83;
6497
6498 return enumeration<DerivativesInstrumentType>(value, offset, NullUInt8());
6499 }
6500
6502 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6503 bool
6504 expiryCycleType(
6505 ExpiryCycleType::Enum& value) const
6506 noexcept
6507 {
6508 constexpr BlockLength offset = 84;
6509
6510 return enumeration<ExpiryCycleType>(value, offset, NullUInt8());
6511 }
6512
6514 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6515 bool underlyingDerivativesInstrumentTradingCode(StrRef& value) const
6516 noexcept
6517 {
6518 constexpr BlockLength offset = 85;
6519 constexpr BlockLength length = 18;
6520
6521 return fixedStr<length>(value, offset);
6522 }
6523
6525 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6526 bool underlyingSymbolIndex(Uint32& value) const
6527 noexcept
6528 {
6529 constexpr BlockLength offset = 103;
6530
6531 return ordinary(value, offset, NullUint32());
6532 }
6533
6535 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6536 bool tradingUnit(Uint64& value) const
6537 noexcept
6538 {
6539 constexpr BlockLength offset = 107;
6540
6541 return ordinary(value, offset, NullUint64());
6542 }
6543
6545 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6546 bool lotMultiplier(Uint64& value) const
6547 noexcept
6548 {
6549 constexpr BlockLength offset = 115;
6550 constexpr SchemaVersion since = 327;
6551
6552 return ordinary(value, offset, NullUint64(), since);
6553 }
6554
6556 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6557 bool expirationDate(Uint16& value) const
6558 noexcept
6559 {
6560 constexpr BlockLength offset = 123;
6561 constexpr SchemaVersion since = 327;
6562
6563 return ordinary(value, offset, NullUint16(), since);
6564 }
6565
6567 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6568 OutrightRep outrightRep() const
6569 noexcept
6570 {
6571 return getGroup<OutrightRep>(
6572 OutrightRepAccess(),
6573 *this);
6574 }
6575
6577 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6578 constexpr
6579 static BlockLength minimalBlockLength(SchemaVersion version)
6580 noexcept
6581 {
6582 return
6583 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6584 (version >= 327)
6585 ? 125
6586 : 115;
6587 }
6588
6590 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6591 constexpr
6592 static BlockLength blockLength(SchemaVersion version)
6593 noexcept
6594 {
6595 return
6596 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6597 minimalBlockLength(version);
6598 }
6599
6601 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6602 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6603 constexpr
6604 static
6605 MessageSize
6606 getMinimalVariableFieldsSize(
6607 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6608 {
6609 return
6610 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6611 static_cast<MessageSize>(OutrightRep::EmptySize);
6612 }
6613
6615 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6616 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6617 constexpr
6618 static StrRef className()
6619 noexcept
6620 {
6621 return constructStrRef("OutrightStandingData");
6622 }
6623
6625 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6626 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6627 constexpr
6628 static StrRef fixType()
6629 noexcept
6630 {
6631 return constructStrRef("OutrightStandingData");
6632 }
6633
6635 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6636 std::string toString() const;
6637
6638private:
6639 void checkLength(
6640 EncodedLength length, SchemaVersion version) const
6641 {
6642 const EncodedLength minimalRequiredLength =
6643 minimalBlockLength(version) +
6644 MessageHeader::Size +
6645 getMinimalVariableFieldsSize(version);
6646
6647 checkBinaryLength(
6648 *this, length, minimalRequiredLength);
6649 }
6650
6652 void checkVarLenFields() const
6653 {
6654 groups().
6655 checkTail<OutrightRep>();
6656 }
6657
6658 void checkCompatibility() const
6659 {
6660 assert(TemplateId == templateId());
6661
6662 checkSchema<Schema>(schemaId(), version());
6663 checkLength(bufferSize(), version());
6664 checkVarLenFields();
6665 }
6666
6668 struct OutrightRepAccess
6669 {
6670 OutrightRep
6671 operator()(
6672 const OutrightStandingData& obj) const
6673 noexcept
6674 {
6675 return obj.
6676 groups().
6677 head<OutrightRep>();
6678 }
6679 };
6680};
6681
6683ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
6684LongOrderUpdate
6685: SbeMessage
6686{
6688 typedef SchemaTraits Schema;
6689
6691 enum { TemplateId = 1015 };
6692
6695 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
6696 OrdersEntry : SbeGroupEntry
6697 <
6698 GroupSizeEncoding::BlockLength
6699 >
6700 {
6702 typedef
6703 SbeGroupEntry
6704 <
6705 GroupSizeEncoding::BlockLength
6706 >
6707 Base;
6708
6711 OrdersEntry(
6712 const void* data,
6713 EncodedLength length,
6714 SchemaVersion version)
6715 : Base(data, numericCast<Base::BlockLength>(length), version)
6716 {
6717 assert(version >= Schema::MinimalVersion);
6718 assert(length >= minimalBlockLength(version));
6719 }
6720
6722 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6723 bool symbolIndex(Uint32& value) const
6724 noexcept
6725 {
6726 constexpr BlockLength offset = 0;
6727
6728 return ordinary(value, offset, NullUint32());
6729 }
6730
6732 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6733 MarketDataActionType::Enum
6734 actionType() const
6735 noexcept
6736 {
6737 constexpr BlockLength offset = 4;
6738
6739 return enumeration<MarketDataActionType>(offset);
6740 }
6741
6743 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6744 bool orderPriority(Uint64& value) const
6745 noexcept
6746 {
6747 constexpr BlockLength offset = 5;
6748
6749 return ordinary(value, offset, NullUint64());
6750 }
6751
6753 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6754 bool previousPriority(Uint64& value) const
6755 noexcept
6756 {
6757 constexpr BlockLength offset = 13;
6758
6759 return ordinary(value, offset, NullUint64());
6760 }
6761
6763 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6764 bool orderType(OrderType::Enum& value) const
6765 noexcept
6766 {
6767 constexpr BlockLength offset = 21;
6768
6769 return enumeration<OrderType>(value, offset, NullUInt8());
6770 }
6771
6773 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6774 bool orderPx(Int64& value) const
6775 noexcept
6776 {
6777 constexpr BlockLength offset = 22;
6778
6779 return ordinary(value, offset, NullInt64());
6780 }
6781
6783 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6784 bool orderSide(OrderSide::Enum& value) const
6785 noexcept
6786 {
6787 constexpr BlockLength offset = 30;
6788
6789 return enumeration<OrderSide>(value, offset, NullUInt8());
6790 }
6791
6793 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6794 bool orderQuantity(Uint64& value) const
6795 noexcept
6796 {
6797 constexpr BlockLength offset = 31;
6798
6799 return ordinary(value, offset, NullUint64());
6800 }
6801
6803 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6804 bool pegOffset(Int8& value) const
6805 noexcept
6806 {
6807 constexpr BlockLength offset = 39;
6808
6809 return ordinary(value, offset, NullInt8());
6810 }
6811
6813 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6814 StrRef firmId() const
6815 noexcept
6816 {
6817 constexpr BlockLength offset = 40;
6818 constexpr BlockLength length = 8;
6819
6820 return fixedStr<length>(offset);
6821 }
6822
6824 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6825 AccountType::Enum accountType() const
6826 noexcept
6827 {
6828 constexpr BlockLength offset = 48;
6829
6830 return enumeration<AccountType>(offset);
6831 }
6832
6835 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6836 constexpr
6837 static BlockLength blockLength(SchemaVersion version)
6838 noexcept
6839 {
6840 return
6841 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6842 minimalBlockLength(version);
6843 }
6844
6847 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6848 constexpr
6849 static
6850 BlockLength
6851 minimalBlockLength(
6852 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6853 noexcept
6854 {
6855 return
6856 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6857 49;
6858 }
6859
6861 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6862 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6863 constexpr
6864 static StrRef className()
6865 noexcept
6866 {
6867 return constructStrRef("LongOrderUpdate.OrdersEntry");
6868 }
6869 };
6870
6872 typedef
6873 SbeGroup<OrdersEntry, GroupSizeEncoding, MessageSize>
6874 Orders;
6875
6877 LongOrderUpdate() =default;
6878
6880 LongOrderUpdate(
6881 const void* data,
6882 EncodedLength length)
6883 : SbeMessage(data, length)
6884 {
6885 checkCompatibility();
6886 }
6887
6889 explicit
6890 LongOrderUpdate(
6891 const SbeMessage& message)
6892 : SbeMessage(message)
6893 {
6894 assert(message.valid());
6895
6896 checkCompatibility();
6897 }
6898
6900 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6901 bool seqNum(Uint64& value) const
6902 noexcept
6903 {
6904 constexpr BlockLength offset = 0;
6905
6906 return ordinary(value, offset, NullUint64());
6907 }
6908
6910 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6911 bool rebroadcastIndicator(UnsignedChar& value) const
6912 noexcept
6913 {
6914 constexpr BlockLength offset = 8;
6915
6916 return ordinary(value, offset, NullUnsignedChar());
6917 }
6918
6920 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6921 Emm::Enum eMM() const
6922 noexcept
6923 {
6924 constexpr BlockLength offset = 9;
6925
6926 return enumeration<Emm>(offset);
6927 }
6928
6930 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6931 bool eventTime(Uint64& value) const
6932 noexcept
6933 {
6934 constexpr BlockLength offset = 10;
6935
6936 return ordinary(value, offset, NullUint64());
6937 }
6938
6940 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6941 Orders orders() const
6942 noexcept
6943 {
6944 return getGroup<Orders>(OrdersAccess(), *this);
6945 }
6946
6948 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6949 constexpr
6950 static
6951 BlockLength
6952 minimalBlockLength(
6953 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6954 noexcept
6955 {
6956 return
6957 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6958 18;
6959 }
6960
6962 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6963 constexpr
6964 static BlockLength blockLength(SchemaVersion version)
6965 noexcept
6966 {
6967 return
6968 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6969 minimalBlockLength(version);
6970 }
6971
6973 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6974 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6975 constexpr
6976 static
6977 MessageSize
6978 getMinimalVariableFieldsSize(
6979 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6980 {
6981 return
6982 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6983 static_cast<MessageSize>(Orders::EmptySize);
6984 }
6985
6987 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6988 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6989 constexpr
6990 static StrRef className()
6991 noexcept
6992 {
6993 return constructStrRef("LongOrderUpdate");
6994 }
6995
6997 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6998 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6999 constexpr
7000 static StrRef fixType()
7001 noexcept
7002 {
7003 return constructStrRef("LongOrderUpdate");
7004 }
7005
7007 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7008 std::string toString() const;
7009
7010private:
7011 void checkLength(
7012 EncodedLength length, SchemaVersion version) const
7013 {
7014 const EncodedLength minimalRequiredLength =
7015 minimalBlockLength(version) +
7016 MessageHeader::Size +
7017 getMinimalVariableFieldsSize(version);
7018
7019 checkBinaryLength(
7020 *this, length, minimalRequiredLength);
7021 }
7022
7024 void checkVarLenFields() const
7025 {
7026 groups().
7027 checkTail<Orders>();
7028 }
7029
7030 void checkCompatibility() const
7031 {
7032 assert(TemplateId == templateId());
7033
7034 checkSchema<Schema>(schemaId(), version());
7035 checkLength(bufferSize(), version());
7036 checkVarLenFields();
7037 }
7038
7040 struct OrdersAccess
7041 {
7042 Orders
7043 operator()(
7044 const LongOrderUpdate& obj) const
7045 noexcept
7046 {
7047 return obj.
7048 groups().
7049 head<Orders>();
7050 }
7051 };
7052};
7053
7055ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7056LisPackageStructure
7057: SbeMessage
7058{
7060 typedef SchemaTraits Schema;
7061
7063 enum { TemplateId = 1016 };
7064
7067 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7068 PackageComponentsEntry : SbeGroupEntry
7069 <
7070 GroupSizeEncoding::BlockLength
7071 >
7072 {
7074 typedef
7075 SbeGroupEntry
7076 <
7077 GroupSizeEncoding::BlockLength
7078 >
7079 Base;
7080
7083 PackageComponentsEntry(
7084 const void* data,
7085 EncodedLength length,
7086 SchemaVersion version)
7087 : Base(data, numericCast<Base::BlockLength>(length), version)
7088 {
7089 assert(version >= Schema::MinimalVersion);
7090 assert(length >= minimalBlockLength(version));
7091 }
7092
7094 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7095 bool legSymbolIndex(Uint32& value) const
7096 noexcept
7097 {
7098 constexpr BlockLength offset = 0;
7099
7100 return ordinary(value, offset, NullUint32());
7101 }
7102
7104 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7105 bool legRatio(Uint32& value) const
7106 noexcept
7107 {
7108 constexpr BlockLength offset = 4;
7109
7110 return ordinary(value, offset, NullUint32());
7111 }
7112
7114 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7115 bool legLastPx(Int64& value) const
7116 noexcept
7117 {
7118 constexpr BlockLength offset = 8;
7119
7120 return ordinary(value, offset, NullInt64());
7121 }
7122
7124 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7125 bool legLastQty(Uint64& value) const
7126 noexcept
7127 {
7128 constexpr BlockLength offset = 16;
7129
7130 return ordinary(value, offset, NullUint64());
7131 }
7132
7135 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7136 constexpr
7137 static BlockLength blockLength(SchemaVersion version)
7138 noexcept
7139 {
7140 return
7141 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7142 minimalBlockLength(version);
7143 }
7144
7147 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7148 constexpr
7149 static
7150 BlockLength
7151 minimalBlockLength(
7152 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7153 noexcept
7154 {
7155 return
7156 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7157 24;
7158 }
7159
7161 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7162 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7163 constexpr
7164 static StrRef className()
7165 noexcept
7166 {
7167 return constructStrRef("LisPackageStructure.PackageComponentsEntry");
7168 }
7169 };
7170
7172 typedef
7173 SbeGroup<PackageComponentsEntry, GroupSizeEncoding, MessageSize>
7174 PackageComponents;
7175
7177 LisPackageStructure() =default;
7178
7180 LisPackageStructure(
7181 const void* data,
7182 EncodedLength length)
7183 : SbeMessage(data, length)
7184 {
7185 checkCompatibility();
7186 }
7187
7189 explicit
7190 LisPackageStructure(
7191 const SbeMessage& message)
7192 : SbeMessage(message)
7193 {
7194 assert(message.valid());
7195
7196 checkCompatibility();
7197 }
7198
7200 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7201 bool seqNum(Uint64& value) const
7202 noexcept
7203 {
7204 constexpr BlockLength offset = 0;
7205
7206 return ordinary(value, offset, NullUint64());
7207 }
7208
7210 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7211 bool rebroadcastIndicator(UnsignedChar& value) const
7212 noexcept
7213 {
7214 constexpr BlockLength offset = 8;
7215
7216 return ordinary(value, offset, NullUnsignedChar());
7217 }
7218
7220 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7221 Emm::Enum eMM() const
7222 noexcept
7223 {
7224 constexpr BlockLength offset = 9;
7225
7226 return enumeration<Emm>(offset);
7227 }
7228
7230 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7231 bool eventTime(Uint64& value) const
7232 noexcept
7233 {
7234 constexpr BlockLength offset = 10;
7235
7236 return ordinary(value, offset, NullUint64());
7237 }
7238
7240 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7241 bool contractSymbolIndex(Uint32& value) const
7242 noexcept
7243 {
7244 constexpr BlockLength offset = 18;
7245
7246 return ordinary(value, offset, NullUint32());
7247 }
7248
7250 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7251 StrRef mifidExecutionId() const
7252 noexcept
7253 {
7254 constexpr BlockLength offset = 22;
7255 constexpr BlockLength length = 52;
7256
7257 return fixedStr<length>(offset);
7258 }
7259
7261 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7262 StrategyCode::Enum strategyCode() const
7263 noexcept
7264 {
7265 constexpr BlockLength offset = 74;
7266
7267 return enumeration<StrategyCode>(offset);
7268 }
7269
7271 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7272 PackageComponents packageComponents() const
7273 noexcept
7274 {
7275 return getGroup<PackageComponents>(
7276 PackageComponentsAccess(),
7277 *this);
7278 }
7279
7281 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7282 constexpr
7283 static
7284 BlockLength
7285 minimalBlockLength(
7286 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7287 noexcept
7288 {
7289 return
7290 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7291 75;
7292 }
7293
7295 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7296 constexpr
7297 static BlockLength blockLength(SchemaVersion version)
7298 noexcept
7299 {
7300 return
7301 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7302 minimalBlockLength(version);
7303 }
7304
7306 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7307 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7308 constexpr
7309 static
7310 MessageSize
7311 getMinimalVariableFieldsSize(
7312 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7313 {
7314 return
7315 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7316 static_cast<MessageSize>(PackageComponents::EmptySize);
7317 }
7318
7320 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7321 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7322 constexpr
7323 static StrRef className()
7324 noexcept
7325 {
7326 return constructStrRef("LisPackageStructure");
7327 }
7328
7330 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7331 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7332 constexpr
7333 static StrRef fixType()
7334 noexcept
7335 {
7336 return constructStrRef("LISPackageStructure");
7337 }
7338
7340 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7341 std::string toString() const;
7342
7343private:
7344 void checkLength(
7345 EncodedLength length, SchemaVersion version) const
7346 {
7347 const EncodedLength minimalRequiredLength =
7348 minimalBlockLength(version) +
7349 MessageHeader::Size +
7350 getMinimalVariableFieldsSize(version);
7351
7352 checkBinaryLength(
7353 *this, length, minimalRequiredLength);
7354 }
7355
7357 void checkVarLenFields() const
7358 {
7359 groups().
7360 checkTail<PackageComponents>();
7361 }
7362
7363 void checkCompatibility() const
7364 {
7365 assert(TemplateId == templateId());
7366
7367 checkSchema<Schema>(schemaId(), version());
7368 checkLength(bufferSize(), version());
7369 checkVarLenFields();
7370 }
7371
7373 struct PackageComponentsAccess
7374 {
7375 PackageComponents
7376 operator()(
7377 const LisPackageStructure& obj) const
7378 noexcept
7379 {
7380 return obj.
7381 groups().
7382 head<PackageComponents>();
7383 }
7384 };
7385};
7386
7388ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7389ApaQuotes
7390: SbeMessage
7391{
7393 typedef SchemaTraits Schema;
7394
7396 enum { TemplateId = 1026 };
7397
7399 ApaQuotes() =default;
7400
7402 ApaQuotes(
7403 const void* data,
7404 EncodedLength length)
7405 : SbeMessage(data, length)
7406 {
7407 checkCompatibility();
7408 }
7409
7411 explicit
7412 ApaQuotes(
7413 const SbeMessage& message)
7414 : SbeMessage(message)
7415 {
7416 assert(message.valid());
7417
7418 checkCompatibility();
7419 }
7420
7422 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7423 bool seqNum(Uint64& value) const
7424 noexcept
7425 {
7426 constexpr BlockLength offset = 0;
7427
7428 return ordinary(value, offset, NullUint64());
7429 }
7430
7432 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7433 bool rebroadcastIndicator(UnsignedChar& value) const
7434 noexcept
7435 {
7436 constexpr BlockLength offset = 8;
7437
7438 return ordinary(value, offset, NullUnsignedChar());
7439 }
7440
7442 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7443 StrRef mifidInstrumentIdType() const
7444 noexcept
7445 {
7446 constexpr BlockLength offset = 9;
7447 constexpr BlockLength length = 4;
7448
7449 return fixedStr<length>(offset);
7450 }
7451
7453 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7454 StrRef mifidInstrumentId() const
7455 noexcept
7456 {
7457 constexpr BlockLength offset = 13;
7458 constexpr BlockLength length = 12;
7459
7460 return fixedStr<length>(offset);
7461 }
7462
7464 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7465 StrRef mIC() const
7466 noexcept
7467 {
7468 constexpr BlockLength offset = 25;
7469 constexpr BlockLength length = 4;
7470
7471 return fixedStr<length>(offset);
7472 }
7473
7475 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7476 StrRef currency() const
7477 noexcept
7478 {
7479 constexpr BlockLength offset = 29;
7480 constexpr BlockLength length = 3;
7481
7482 return fixedStr<length>(offset);
7483 }
7484
7486 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7487 StrRef lEICode() const
7488 noexcept
7489 {
7490 constexpr BlockLength offset = 32;
7491 constexpr BlockLength length = 20;
7492
7493 return fixedStr<length>(offset);
7494 }
7495
7497 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7498 bool eventTime(Uint64& value) const
7499 noexcept
7500 {
7501 constexpr BlockLength offset = 52;
7502
7503 return ordinary(value, offset, NullUint64());
7504 }
7505
7507 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7508 QuoteUpdateType::Enum quoteUpdateType() const
7509 noexcept
7510 {
7511 constexpr BlockLength offset = 60;
7512
7513 return enumeration<QuoteUpdateType>(offset);
7514 }
7515
7517 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7518 StrRef mifidPrice() const
7519 noexcept
7520 {
7521 constexpr BlockLength offset = 61;
7522 constexpr BlockLength length = 20;
7523
7524 return fixedStr<length>(offset);
7525 }
7526
7528 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7529 StrRef mifidQuantity() const
7530 noexcept
7531 {
7532 constexpr BlockLength offset = 81;
7533 constexpr BlockLength length = 20;
7534
7535 return fixedStr<length>(offset);
7536 }
7537
7539 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7540 bool aPAOrigin(StrRef& value) const
7541 noexcept
7542 {
7543 constexpr BlockLength offset = 101;
7544 constexpr BlockLength length = 4;
7545
7546 return fixedStr<length>(value, offset);
7547 }
7548
7550 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7551 constexpr
7552 static
7553 BlockLength
7554 minimalBlockLength(
7555 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7556 noexcept
7557 {
7558 return
7559 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7560 105;
7561 }
7562
7564 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7565 constexpr
7566 static BlockLength blockLength(SchemaVersion version)
7567 noexcept
7568 {
7569 return
7570 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7571 minimalBlockLength(version);
7572 }
7573
7575 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7576 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7577 constexpr
7578 static
7579 MessageSize
7580 getMinimalVariableFieldsSize(
7581 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7582 {
7583 return
7584 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7585 0;
7586 }
7587
7589 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7590 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7591 constexpr
7592 static StrRef className()
7593 noexcept
7594 {
7595 return constructStrRef("ApaQuotes");
7596 }
7597
7599 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7600 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7601 constexpr
7602 static StrRef fixType()
7603 noexcept
7604 {
7605 return constructStrRef("APAQuotes");
7606 }
7607
7609 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7610 std::string toString() const;
7611
7612private:
7613 void checkLength(
7614 EncodedLength length, SchemaVersion version) const
7615 {
7616 const EncodedLength minimalRequiredLength =
7617 minimalBlockLength(version) +
7618 MessageHeader::Size +
7619 getMinimalVariableFieldsSize(version);
7620
7621 checkBinaryLength(
7622 *this, length, minimalRequiredLength);
7623 }
7624
7625 void checkCompatibility() const
7626 {
7627 assert(TemplateId == templateId());
7628
7629 checkSchema<Schema>(schemaId(), version());
7630 checkLength(bufferSize(), version());
7631 }
7632};
7633
7635ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7636ApaStandingData
7637: SbeMessage
7638{
7640 typedef SchemaTraits Schema;
7641
7643 enum { TemplateId = 1027 };
7644
7646 ApaStandingData() =default;
7647
7649 ApaStandingData(
7650 const void* data,
7651 EncodedLength length)
7652 : SbeMessage(data, length)
7653 {
7654 checkCompatibility();
7655 }
7656
7658 explicit
7659 ApaStandingData(
7660 const SbeMessage& message)
7661 : SbeMessage(message)
7662 {
7663 assert(message.valid());
7664
7665 checkCompatibility();
7666 }
7667
7669 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7670 bool seqNum(Uint64& value) const
7671 noexcept
7672 {
7673 constexpr BlockLength offset = 0;
7674
7675 return ordinary(value, offset, NullUint64());
7676 }
7677
7679 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7680 bool rebroadcastIndicator(UnsignedChar& value) const
7681 noexcept
7682 {
7683 constexpr BlockLength offset = 8;
7684
7685 return ordinary(value, offset, NullUnsignedChar());
7686 }
7687
7689 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7690 StrRef mifidInstrumentIdType() const
7691 noexcept
7692 {
7693 constexpr BlockLength offset = 9;
7694 constexpr BlockLength length = 4;
7695
7696 return fixedStr<length>(offset);
7697 }
7698
7700 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7701 StrRef mifidInstrumentId() const
7702 noexcept
7703 {
7704 constexpr BlockLength offset = 13;
7705 constexpr BlockLength length = 12;
7706
7707 return fixedStr<length>(offset);
7708 }
7709
7711 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7712 bool fullInstrumentName(StrRef& value) const
7713 noexcept
7714 {
7715 constexpr BlockLength offset = 25;
7716 constexpr BlockLength length = 102;
7717
7718 return fixedStr<length>(value, offset);
7719 }
7720
7722 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7723 bool cFI(StrRef& value) const
7724 noexcept
7725 {
7726 constexpr BlockLength offset = 127;
7727 constexpr BlockLength length = 6;
7728
7729 return fixedStr<length>(value, offset);
7730 }
7731
7733 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7734 bool notionalCurrency(StrRef& value) const
7735 noexcept
7736 {
7737 constexpr BlockLength offset = 133;
7738 constexpr BlockLength length = 3;
7739
7740 return fixedStr<length>(value, offset);
7741 }
7742
7744 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7745 bool secondNotionalCurrency(StrRef& value) const
7746 noexcept
7747 {
7748 constexpr BlockLength offset = 136;
7749 constexpr BlockLength length = 3;
7750
7751 return fixedStr<length>(value, offset);
7752 }
7753
7755 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7756 bool priceMultiplier(Uint32& value) const
7757 noexcept
7758 {
7759 constexpr BlockLength offset = 139;
7760
7761 return ordinary(value, offset, NullUint32());
7762 }
7763
7765 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7766 bool priceMultiplierDecimals(UnsignedChar& value) const
7767 noexcept
7768 {
7769 constexpr BlockLength offset = 143;
7770
7771 return ordinary(value, offset, NullUnsignedChar());
7772 }
7773
7775 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7776 bool underlyingISINCode(StrRef& value) const
7777 noexcept
7778 {
7779 constexpr BlockLength offset = 144;
7780 constexpr BlockLength length = 12;
7781
7782 return fixedStr<length>(value, offset);
7783 }
7784
7786 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7787 bool underlyingIndexName(StrRef& value) const
7788 noexcept
7789 {
7790 constexpr BlockLength offset = 156;
7791 constexpr BlockLength length = 25;
7792
7793 return fixedStr<length>(value, offset);
7794 }
7795
7797 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7798 bool underlyingIndexTerm(StrRef& value) const
7799 noexcept
7800 {
7801 constexpr BlockLength offset = 181;
7802 constexpr BlockLength length = 8;
7803
7804 return fixedStr<length>(value, offset);
7805 }
7806
7808 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7809 bool optionType(OptionType::Enum& value) const
7810 noexcept
7811 {
7812 constexpr BlockLength offset = 189;
7813
7814 return enumeration<OptionType>(value, offset, NullUInt8());
7815 }
7816
7818 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7819 bool strikePrice(Int64& value) const
7820 noexcept
7821 {
7822 constexpr BlockLength offset = 190;
7823
7824 return ordinary(value, offset, NullInt64());
7825 }
7826
7828 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7829 bool strikePriceDecimals(UnsignedChar& value) const
7830 noexcept
7831 {
7832 constexpr BlockLength offset = 198;
7833
7834 return ordinary(value, offset, NullUnsignedChar());
7835 }
7836
7838 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7839 bool
7840 exerStyle(
7841 ExerciseStyle::Enum& value) const
7842 noexcept
7843 {
7844 constexpr BlockLength offset = 199;
7845
7846 return enumeration<ExerciseStyle>(value, offset, NullUInt8());
7847 }
7848
7850 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7851 bool maturityDate(StrRef& value) const
7852 noexcept
7853 {
7854 constexpr BlockLength offset = 200;
7855 constexpr BlockLength length = 8;
7856
7857 return fixedStr<length>(value, offset);
7858 }
7859
7861 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7862 bool expiryDate(StrRef& value) const
7863 noexcept
7864 {
7865 constexpr BlockLength offset = 208;
7866 constexpr BlockLength length = 8;
7867
7868 return fixedStr<length>(value, offset);
7869 }
7870
7872 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7873 bool settlementMethod(Char& value) const
7874 noexcept
7875 {
7876 constexpr BlockLength offset = 216;
7877
7878 return ordinary(value, offset, NullChar());
7879 }
7880
7882 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7883 constexpr
7884 static
7885 BlockLength
7886 minimalBlockLength(
7887 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7888 noexcept
7889 {
7890 return
7891 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7892 217;
7893 }
7894
7896 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7897 constexpr
7898 static BlockLength blockLength(SchemaVersion version)
7899 noexcept
7900 {
7901 return
7902 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7903 minimalBlockLength(version);
7904 }
7905
7907 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7908 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7909 constexpr
7910 static
7911 MessageSize
7912 getMinimalVariableFieldsSize(
7913 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7914 {
7915 return
7916 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7917 0;
7918 }
7919
7921 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7922 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7923 constexpr
7924 static StrRef className()
7925 noexcept
7926 {
7927 return constructStrRef("ApaStandingData");
7928 }
7929
7931 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7932 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7933 constexpr
7934 static StrRef fixType()
7935 noexcept
7936 {
7937 return constructStrRef("APAStandingData");
7938 }
7939
7941 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7942 std::string toString() const;
7943
7944private:
7945 void checkLength(
7946 EncodedLength length, SchemaVersion version) const
7947 {
7948 const EncodedLength minimalRequiredLength =
7949 minimalBlockLength(version) +
7950 MessageHeader::Size +
7951 getMinimalVariableFieldsSize(version);
7952
7953 checkBinaryLength(
7954 *this, length, minimalRequiredLength);
7955 }
7956
7957 void checkCompatibility() const
7958 {
7959 assert(TemplateId == templateId());
7960
7961 checkSchema<Schema>(schemaId(), version());
7962 checkLength(bufferSize(), version());
7963 }
7964};
7965
7967ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7968ApaFullTradeInformation
7969: SbeMessage
7970{
7972 typedef SchemaTraits Schema;
7973
7975 enum { TemplateId = 1028 };
7976
7978 ApaFullTradeInformation() =default;
7979
7981 ApaFullTradeInformation(
7982 const void* data,
7983 EncodedLength length)
7984 : SbeMessage(data, length)
7985 {
7986 checkCompatibility();
7987 }
7988
7990 explicit
7991 ApaFullTradeInformation(
7992 const SbeMessage& message)
7993 : SbeMessage(message)
7994 {
7995 assert(message.valid());
7996
7997 checkCompatibility();
7998 }
7999
8001 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8002 bool seqNum(Uint64& value) const
8003 noexcept
8004 {
8005 constexpr BlockLength offset = 0;
8006
8007 return ordinary(value, offset, NullUint64());
8008 }
8009
8011 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8012 bool rebroadcastIndicator(UnsignedChar& value) const
8013 noexcept
8014 {
8015 constexpr BlockLength offset = 8;
8016
8017 return ordinary(value, offset, NullUnsignedChar());
8018 }
8019
8021 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8022 Emm::Enum eMM() const
8023 noexcept
8024 {
8025 constexpr BlockLength offset = 9;
8026
8027 return enumeration<Emm>(offset);
8028 }
8029
8031 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8032 bool eventTime(Uint64& value) const
8033 noexcept
8034 {
8035 constexpr BlockLength offset = 10;
8036
8037 return ordinary(value, offset, NullUint64());
8038 }
8039
8041 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8042 StrRef tradingDateTime() const
8043 noexcept
8044 {
8045 constexpr BlockLength offset = 18;
8046 constexpr BlockLength length = 27;
8047
8048 return fixedStr<length>(offset);
8049 }
8050
8052 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8053 bool publicationDateTime(StrRef& value) const
8054 noexcept
8055 {
8056 constexpr BlockLength offset = 45;
8057 constexpr BlockLength length = 27;
8058
8059 return fixedStr<length>(value, offset);
8060 }
8061
8063 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8064 TradeType::Enum tradeType() const
8065 noexcept
8066 {
8067 constexpr BlockLength offset = 72;
8068
8069 return enumeration<TradeType>(offset);
8070 }
8071
8073 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8074 bool mifidInstrumentIdType(StrRef& value) const
8075 noexcept
8076 {
8077 constexpr BlockLength offset = 73;
8078 constexpr BlockLength length = 4;
8079
8080 return fixedStr<length>(value, offset);
8081 }
8082
8084 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8085 bool mifidInstrumentId(StrRef& value) const
8086 noexcept
8087 {
8088 constexpr BlockLength offset = 77;
8089 constexpr BlockLength length = 12;
8090
8091 return fixedStr<length>(value, offset);
8092 }
8093
8095 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8096 StrRef miFIdTransactionId() const
8097 noexcept
8098 {
8099 constexpr BlockLength offset = 89;
8100 constexpr BlockLength length = 52;
8101
8102 return fixedStr<length>(offset);
8103 }
8104
8106 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8107 bool mifidPrice(StrRef& value) const
8108 noexcept
8109 {
8110 constexpr BlockLength offset = 141;
8111 constexpr BlockLength length = 20;
8112
8113 return fixedStr<length>(value, offset);
8114 }
8115
8117 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8118 StrRef mifidQuantity() const
8119 noexcept
8120 {
8121 constexpr BlockLength offset = 161;
8122 constexpr BlockLength length = 20;
8123
8124 return fixedStr<length>(offset);
8125 }
8126
8128 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8129 bool mifidPriceNotation(StrRef& value) const
8130 noexcept
8131 {
8132 constexpr BlockLength offset = 181;
8133 constexpr BlockLength length = 4;
8134
8135 return fixedStr<length>(value, offset);
8136 }
8137
8139 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8140 bool mifidCurrency(StrRef& value) const
8141 noexcept
8142 {
8143 constexpr BlockLength offset = 185;
8144 constexpr BlockLength length = 3;
8145
8146 return fixedStr<length>(value, offset);
8147 }
8148
8150 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8151 bool miFIdQtyinMsrmtUnitNotation(StrRef& value) const
8152 noexcept
8153 {
8154 constexpr BlockLength offset = 188;
8155 constexpr BlockLength length = 25;
8156
8157 return fixedStr<length>(value, offset);
8158 }
8159
8161 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8162 bool mifidQuantityMeasurementUnit(StrRef& value) const
8163 noexcept
8164 {
8165 constexpr BlockLength offset = 213;
8166 constexpr BlockLength length = 20;
8167
8168 return fixedStr<length>(value, offset);
8169 }
8170
8172 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8173 bool miFIdNotionalAmount(StrRef& value) const
8174 noexcept
8175 {
8176 constexpr BlockLength offset = 233;
8177 constexpr BlockLength length = 20;
8178
8179 return fixedStr<length>(value, offset);
8180 }
8181
8183 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8184 bool notionalCurrency(StrRef& value) const
8185 noexcept
8186 {
8187 constexpr BlockLength offset = 253;
8188 constexpr BlockLength length = 3;
8189
8190 return fixedStr<length>(value, offset);
8191 }
8192
8194 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8195 bool miFIdClearingFlag(StrRef& value) const
8196 noexcept
8197 {
8198 constexpr BlockLength offset = 256;
8199 constexpr BlockLength length = 5;
8200
8201 return fixedStr<length>(value, offset);
8202 }
8203
8205 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8206 bool
8207 efficientMMTMarketMechanism(
8208 EfficientMMTMarketMechanism::Enum& value) const
8209 noexcept
8210 {
8211 constexpr BlockLength offset = 261;
8212
8213 return enumeration<EfficientMMTMarketMechanism>(value, offset, NullUInt8());
8214 }
8215
8217 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8218 bool
8219 efficientMMTTradingMode(
8220 EfficientMMTTradingMode::Enum& value) const
8221 noexcept
8222 {
8223 constexpr BlockLength offset = 262;
8224
8225 return enumeration<EfficientMMTTradingMode>(value, offset, NullChar());
8226 }
8227
8229 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8230 bool
8231 efficientMMTTransactionCategory(
8232 EfficientMMTTransactionCategory::Enum& value) const
8233 noexcept
8234 {
8235 constexpr BlockLength offset = 263;
8236
8237 return enumeration<EfficientMMTTransactionCategory>(value, offset, NullChar());
8238 }
8239
8241 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8242 bool
8243 efficientMMTNegotiationIndicator(
8244 EfficientMMTNegotiationIndicator::Enum& value) const
8245 noexcept
8246 {
8247 constexpr BlockLength offset = 264;
8248
8249 return enumeration<EfficientMMTNegotiationIndicator>(value, offset, NullChar());
8250 }
8251
8253 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8254 bool
8255 efficientMMTAgencyCrossTradeIndicator(
8256 EfficientMMTAgencyCrossTradeIndicator::Enum& value) const
8257 noexcept
8258 {
8259 constexpr BlockLength offset = 265;
8260
8261 return enumeration<EfficientMMTAgencyCrossTradeIndicator>(value, offset, NullChar());
8262 }
8263
8265 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8266 bool
8267 efficientMMTModificationIndicator(
8268 EfficientMMTModificationIndicator::Enum& value) const
8269 noexcept
8270 {
8271 constexpr BlockLength offset = 266;
8272
8273 return enumeration<EfficientMMTModificationIndicator>(value, offset, NullChar());
8274 }
8275
8277 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8278 bool
8279 efficientMMTBenchmarkIndicator(
8280 EfficientMMTBenchmarkIndicator::Enum& value) const
8281 noexcept
8282 {
8283 constexpr BlockLength offset = 267;
8284
8285 return enumeration<EfficientMMTBenchmarkIndicator>(value, offset, NullChar());
8286 }
8287
8289 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8290 bool
8291 efficientMMTSpecialDividendIndicator(
8292 EfficientMMTSpecialDividendIndicator::Enum& value) const
8293 noexcept
8294 {
8295 constexpr BlockLength offset = 268;
8296
8297 return enumeration<EfficientMMTSpecialDividendIndicator>(value, offset, NullChar());
8298 }
8299
8301 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8302 bool
8303 efficientMMTOffBookAutomatedIndicator(
8304 EfficientMMTOffBookAutomatedIndicator::Enum& value) const
8305 noexcept
8306 {
8307 constexpr BlockLength offset = 269;
8308
8309 return enumeration<EfficientMMTOffBookAutomatedIndicator>(value, offset, NullChar());
8310 }
8311
8313 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8314 bool
8315 efficientMMTContributiontoPrice(
8316 EfficientMMTContributiontoPrice::Enum& value) const
8317 noexcept
8318 {
8319 constexpr BlockLength offset = 270;
8320
8321 return enumeration<EfficientMMTContributiontoPrice>(value, offset, NullChar());
8322 }
8323
8325 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8326 bool
8327 efficientMMTAlgorithmicIndicator(
8328 EfficientMMTAlgorithmicIndicator::Enum& value) const
8329 noexcept
8330 {
8331 constexpr BlockLength offset = 271;
8332
8333 return enumeration<EfficientMMTAlgorithmicIndicator>(value, offset, NullChar());
8334 }
8335
8337 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8338 bool
8339 efficientMMTPublicationMode(
8340 EfficientMMTPublicationMode::Enum& value) const
8341 noexcept
8342 {
8343 constexpr BlockLength offset = 272;
8344
8345 return enumeration<EfficientMMTPublicationMode>(value, offset, NullChar());
8346 }
8347
8349 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8350 bool
8351 efficientMMTPostTradeDeferral(
8352 EfficientMMTPostTradeDeferral::Enum& value) const
8353 noexcept
8354 {
8355 constexpr BlockLength offset = 273;
8356
8357 return enumeration<EfficientMMTPostTradeDeferral>(value, offset, NullChar());
8358 }
8359
8361 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8362 bool
8363 efficientMMTDuplicativeIndicator(
8364 EfficientMMTDuplicativeIndicator::Enum& value) const
8365 noexcept
8366 {
8367 constexpr BlockLength offset = 274;
8368
8369 return enumeration<EfficientMMTDuplicativeIndicator>(value, offset, NullChar());
8370 }
8371
8373 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8374 bool tradeReference(StrRef& value) const
8375 noexcept
8376 {
8377 constexpr BlockLength offset = 275;
8378 constexpr BlockLength length = 30;
8379
8380 return fixedStr<length>(value, offset);
8381 }
8382
8384 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8385 bool originalReportTimestamp(Uint64& value) const
8386 noexcept
8387 {
8388 constexpr BlockLength offset = 305;
8389
8390 return ordinary(value, offset, NullUint64());
8391 }
8392
8394 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8395 bool priceMultiplier(Uint32& value) const
8396 noexcept
8397 {
8398 constexpr BlockLength offset = 313;
8399
8400 return ordinary(value, offset, NullUint32());
8401 }
8402
8404 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8405 bool priceMultiplierDecimals(UnsignedChar& value) const
8406 noexcept
8407 {
8408 constexpr BlockLength offset = 317;
8409
8410 return ordinary(value, offset, NullUnsignedChar());
8411 }
8412
8414 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8415 StrRef venue() const
8416 noexcept
8417 {
8418 constexpr BlockLength offset = 318;
8419 constexpr BlockLength length = 11;
8420
8421 return fixedStr<length>(offset);
8422 }
8423
8425 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8426 bool miFIdEmissionAllowanceType(StrRef& value) const
8427 noexcept
8428 {
8429 constexpr BlockLength offset = 329;
8430 constexpr BlockLength length = 4;
8431
8432 return fixedStr<length>(value, offset);
8433 }
8434
8436 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8437 bool longTradeReference(StrRef& value) const
8438 noexcept
8439 {
8440 constexpr BlockLength offset = 333;
8441 constexpr BlockLength length = 52;
8442
8443 return fixedStr<length>(value, offset);
8444 }
8445
8447 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8448 bool aPAOrigin(StrRef& value) const
8449 noexcept
8450 {
8451 constexpr BlockLength offset = 385;
8452 constexpr BlockLength length = 4;
8453
8454 return fixedStr<length>(value, offset);
8455 }
8456
8458 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8459 bool tradeUniqueIdentifier(StrRef& value) const
8460 noexcept
8461 {
8462 constexpr BlockLength offset = 389;
8463 constexpr BlockLength length = 16;
8464 constexpr SchemaVersion since = 316;
8465
8466 return fixedStr<length>(value, offset, since);
8467 }
8468
8470 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8471 constexpr
8472 static BlockLength minimalBlockLength(SchemaVersion version)
8473 noexcept
8474 {
8475 return
8476 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8477 (version >= 316)
8478 ? 405
8479 : 389;
8480 }
8481
8483 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8484 constexpr
8485 static BlockLength blockLength(SchemaVersion version)
8486 noexcept
8487 {
8488 return
8489 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8490 minimalBlockLength(version);
8491 }
8492
8494 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8495 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8496 constexpr
8497 static
8498 MessageSize
8499 getMinimalVariableFieldsSize(
8500 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
8501 {
8502 return
8503 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8504 0;
8505 }
8506
8508 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8509 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8510 constexpr
8511 static StrRef className()
8512 noexcept
8513 {
8514 return constructStrRef("ApaFullTradeInformation");
8515 }
8516
8518 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8519 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8520 constexpr
8521 static StrRef fixType()
8522 noexcept
8523 {
8524 return constructStrRef(
8525 "APAFullTradeInformation");
8526 }
8527
8529 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8530 std::string toString() const;
8531
8532private:
8533 void checkLength(
8534 EncodedLength length, SchemaVersion version) const
8535 {
8536 const EncodedLength minimalRequiredLength =
8537 minimalBlockLength(version) +
8538 MessageHeader::Size +
8539 getMinimalVariableFieldsSize(version);
8540
8541 checkBinaryLength(
8542 *this, length, minimalRequiredLength);
8543 }
8544
8545 void checkCompatibility() const
8546 {
8547 assert(TemplateId == templateId());
8548
8549 checkSchema<Schema>(schemaId(), version());
8550 checkLength(bufferSize(), version());
8551 }
8552};
8553
8555ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
8556BfInstrumentReference
8557: SbeMessage
8558{
8560 typedef SchemaTraits Schema;
8561
8563 enum { TemplateId = 1201 };
8564
8567 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
8568 InterestPaymentDateRepEntry : SbeGroupEntry
8569 <
8570 GroupSizeEncoding::BlockLength
8571 >
8572 {
8574 typedef
8575 SbeGroupEntry
8576 <
8577 GroupSizeEncoding::BlockLength
8578 >
8579 Base;
8580
8583 InterestPaymentDateRepEntry(
8584 const void* data,
8585 EncodedLength length,
8586 SchemaVersion version)
8587 : Base(data, numericCast<Base::BlockLength>(length), version)
8588 {
8589 assert(version >= Schema::MinimalVersion);
8590 assert(length >= minimalBlockLength(version));
8591 }
8592
8594 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8595 bool interestPaymentDate(Uint16& value) const
8596 noexcept
8597 {
8598 constexpr BlockLength offset = 0;
8599
8600 return ordinary(value, offset, NullUint16());
8601 }
8602
8605 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8606 constexpr
8607 static BlockLength blockLength(SchemaVersion version)
8608 noexcept
8609 {
8610 return
8611 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8612 minimalBlockLength(version);
8613 }
8614
8617 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8618 constexpr
8619 static
8620 BlockLength
8621 minimalBlockLength(
8622 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
8623 noexcept
8624 {
8625 return
8626 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8627 2;
8628 }
8629
8631 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8632 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8633 constexpr
8634 static StrRef className()
8635 noexcept
8636 {
8637 return constructStrRef("BfInstrumentReference.InterestPaymentDateRepEntry");
8638 }
8639 };
8640
8642 typedef
8643 SbeGroup<InterestPaymentDateRepEntry, GroupSizeEncoding, MessageSize>
8644 InterestPaymentDateRep;
8645
8647 BfInstrumentReference() =default;
8648
8650 BfInstrumentReference(
8651 const void* data,
8652 EncodedLength length)
8653 : SbeMessage(data, length)
8654 {
8655 checkCompatibility();
8656 }
8657
8659 explicit
8660 BfInstrumentReference(
8661 const SbeMessage& message)
8662 : SbeMessage(message)
8663 {
8664 assert(message.valid());
8665
8666 checkCompatibility();
8667 }
8668
8670 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8671 bool seqNum(Uint64& value) const
8672 noexcept
8673 {
8674 constexpr BlockLength offset = 0;
8675
8676 return ordinary(value, offset, NullUint64());
8677 }
8678
8680 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8681 bool rebroadcastIndicator(UnsignedChar& value) const
8682 noexcept
8683 {
8684 constexpr BlockLength offset = 8;
8685
8686 return ordinary(value, offset, NullUnsignedChar());
8687 }
8688
8690 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8691 bool symbolIndex(Uint32& value) const
8692 noexcept
8693 {
8694 constexpr BlockLength offset = 9;
8695
8696 return ordinary(value, offset, NullUint32());
8697 }
8698
8700 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8701 OptiqSegment::Enum optiqSegment() const
8702 noexcept
8703 {
8704 constexpr BlockLength offset = 13;
8705
8706 return enumeration<OptiqSegment>(offset);
8707 }
8708
8710 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8711 bool iSINCode(StrRef& value) const
8712 noexcept
8713 {
8714 constexpr BlockLength offset = 14;
8715 constexpr BlockLength length = 12;
8716
8717 return fixedStr<length>(value, offset);
8718 }
8719
8721 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8722 bool sEDOLCode(StrRef& value) const
8723 noexcept
8724 {
8725 constexpr BlockLength offset = 26;
8726 constexpr BlockLength length = 7;
8727
8728 return fixedStr<length>(value, offset);
8729 }
8730
8732 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8733 bool longIssuerName(StrRef& value) const
8734 noexcept
8735 {
8736 constexpr BlockLength offset = 33;
8737 constexpr BlockLength length = 250;
8738
8739 return fixedStr<length>(value, offset);
8740 }
8741
8743 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8744 bool longInstrumentName(StrRef& value) const
8745 noexcept
8746 {
8747 constexpr BlockLength offset = 283;
8748 constexpr BlockLength length = 250;
8749
8750 return fixedStr<length>(value, offset);
8751 }
8752
8754 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8755 bool currency(StrRef& value) const
8756 noexcept
8757 {
8758 constexpr BlockLength offset = 533;
8759 constexpr BlockLength length = 3;
8760
8761 return fixedStr<length>(value, offset);
8762 }
8763
8765 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8766 bool dateOfInitialListing(Uint16& value) const
8767 noexcept
8768 {
8769 constexpr BlockLength offset = 536;
8770
8771 return ordinary(value, offset, NullUint16());
8772 }
8773
8775 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8776 bool shareAmountInIssue(Int64& value) const
8777 noexcept
8778 {
8779 constexpr BlockLength offset = 538;
8780
8781 return ordinary(value, offset, NullInt64());
8782 }
8783
8785 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8786 bool
8787 openedClosedFund(
8788 OpenedClosedFund::Enum& value) const
8789 noexcept
8790 {
8791 constexpr BlockLength offset = 546;
8792
8793 return enumeration<OpenedClosedFund>(value, offset, NullChar());
8794 }
8795
8797 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8798 bool lastNAVPrice(Int64& value) const
8799 noexcept
8800 {
8801 constexpr BlockLength offset = 547;
8802
8803 return ordinary(value, offset, NullInt64());
8804 }
8805
8807 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8808 bool
8809 grossOfCDSCIndicator(
8810 GrossofCDSCIndicator::Enum& value) const
8811 noexcept
8812 {
8813 constexpr BlockLength offset = 555;
8814
8815 return enumeration<GrossofCDSCIndicator>(value, offset, NullChar());
8816 }
8817
8819 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8820 bool coupon(Int64& value) const
8821 noexcept
8822 {
8823 constexpr BlockLength offset = 556;
8824
8825 return ordinary(value, offset, NullInt64());
8826 }
8827
8829 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8830 bool maturityDate(StrRef& value) const
8831 noexcept
8832 {
8833 constexpr BlockLength offset = 564;
8834 constexpr BlockLength length = 8;
8835
8836 return fixedStr<length>(value, offset);
8837 }
8838
8840 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8841 bool closingPrice(Int64& value) const
8842 noexcept
8843 {
8844 constexpr BlockLength offset = 572;
8845
8846 return ordinary(value, offset, NullInt64());
8847 }
8848
8850 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8851 bool mIC(StrRef& value) const
8852 noexcept
8853 {
8854 constexpr BlockLength offset = 580;
8855 constexpr BlockLength length = 4;
8856
8857 return fixedStr<length>(value, offset);
8858 }
8859
8861 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8862 bool grossDividendPayablePerUnit(Int64& value) const
8863 noexcept
8864 {
8865 constexpr BlockLength offset = 584;
8866
8867 return ordinary(value, offset, NullInt64());
8868 }
8869
8871 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8872 bool dividendCurrency(StrRef& value) const
8873 noexcept
8874 {
8875 constexpr BlockLength offset = 592;
8876 constexpr BlockLength length = 3;
8877
8878 return fixedStr<length>(value, offset);
8879 }
8880
8882 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8883 bool dividendRecordDate(Uint16& value) const
8884 noexcept
8885 {
8886 constexpr BlockLength offset = 595;
8887
8888 return ordinary(value, offset, NullUint16());
8889 }
8890
8892 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8893 bool dividendRate(Uint64& value) const
8894 noexcept
8895 {
8896 constexpr BlockLength offset = 597;
8897
8898 return ordinary(value, offset, NullUint64());
8899 }
8900
8902 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8903 bool exDividendDate(Uint16& value) const
8904 noexcept
8905 {
8906 constexpr BlockLength offset = 605;
8907
8908 return ordinary(value, offset, NullUint16());
8909 }
8910
8912 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8913 bool dividendPaymentDate(Uint16& value) const
8914 noexcept
8915 {
8916 constexpr BlockLength offset = 607;
8917
8918 return ordinary(value, offset, NullUint16());
8919 }
8920
8922 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8923 bool
8924 taxDescriptionAttachingToADividend(
8925 TaxDescriptionAttachingtoaDividend::Enum& value) const
8926 noexcept
8927 {
8928 constexpr BlockLength offset = 609;
8929
8930 return enumeration<TaxDescriptionAttachingtoaDividend>(value, offset, NullChar());
8931 }
8932
8934 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8935 bool nextMeeting(StrRef& value) const
8936 noexcept
8937 {
8938 constexpr BlockLength offset = 610;
8939 constexpr BlockLength length = 8;
8940
8941 return fixedStr<length>(value, offset);
8942 }
8943
8945 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8946 bool grossDividendInEuros(Int64& value) const
8947 noexcept
8948 {
8949 constexpr BlockLength offset = 618;
8950
8951 return ordinary(value, offset, NullInt64());
8952 }
8953
8955 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8956 bool issueDate(Uint16& value) const
8957 noexcept
8958 {
8959 constexpr BlockLength offset = 626;
8960
8961 return ordinary(value, offset, NullUint16());
8962 }
8963
8965 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8966 bool issuingCountry(StrRef& value) const
8967 noexcept
8968 {
8969 constexpr BlockLength offset = 628;
8970 constexpr BlockLength length = 3;
8971
8972 return fixedStr<length>(value, offset);
8973 }
8974
8976 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8977 bool cFI(StrRef& value) const
8978 noexcept
8979 {
8980 constexpr BlockLength offset = 631;
8981 constexpr BlockLength length = 6;
8982
8983 return fixedStr<length>(value, offset);
8984 }
8985
8987 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8988 bool
8989 paymentFrequency(
8990 PaymentFrequency::Enum& value) const
8991 noexcept
8992 {
8993 constexpr BlockLength offset = 637;
8994
8995 return enumeration<PaymentFrequency>(value, offset, NullUInt8());
8996 }
8997
8999 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9000 bool minimumAmount(Int64& value) const
9001 noexcept
9002 {
9003 constexpr BlockLength offset = 638;
9004
9005 return ordinary(value, offset, NullInt64());
9006 }
9007
9009 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9010 InstrumentCategory::Enum instrumentCategory() const
9011 noexcept
9012 {
9013 constexpr BlockLength offset = 646;
9014
9015 return enumeration<InstrumentCategory>(offset);
9016 }
9017
9019 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9020 bool
9021 securityCondition(
9022 SecurityCondition::Enum& value) const
9023 noexcept
9024 {
9025 constexpr BlockLength offset = 647;
9026
9027 return enumeration<SecurityCondition>(value, offset, NullChar());
9028 }
9029
9031 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9032 bool miFIdPriceNotation(StrRef& value) const
9033 noexcept
9034 {
9035 constexpr BlockLength offset = 648;
9036 constexpr BlockLength length = 4;
9037
9038 return fixedStr<length>(value, offset);
9039 }
9040
9042 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9043 bool priceIndexLevelDecimals(UnsignedChar& value) const
9044 noexcept
9045 {
9046 constexpr BlockLength offset = 652;
9047
9048 return ordinary(value, offset, NullUnsignedChar());
9049 }
9050
9052 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9053 bool quantityDecimals(UnsignedChar& value) const
9054 noexcept
9055 {
9056 constexpr BlockLength offset = 653;
9057
9058 return ordinary(value, offset, NullUnsignedChar());
9059 }
9060
9062 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9063 bool amountDecimals(UnsignedChar& value) const
9064 noexcept
9065 {
9066 constexpr BlockLength offset = 654;
9067
9068 return ordinary(value, offset, NullUnsignedChar());
9069 }
9070
9072 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9073 bool ratioMultiplierDecimals(UnsignedChar& value) const
9074 noexcept
9075 {
9076 constexpr BlockLength offset = 655;
9077
9078 return ordinary(value, offset, NullUnsignedChar());
9079 }
9080
9082 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9083 InterestPaymentDateRep interestPaymentDateRep() const
9084 noexcept
9085 {
9086 return getGroup<InterestPaymentDateRep>(
9087 InterestPaymentDateRepAccess(),
9088 *this);
9089 }
9090
9092 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9093 constexpr
9094 static
9095 BlockLength
9096 minimalBlockLength(
9097 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9098 noexcept
9099 {
9100 return
9101 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9102 656;
9103 }
9104
9106 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9107 constexpr
9108 static BlockLength blockLength(SchemaVersion version)
9109 noexcept
9110 {
9111 return
9112 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9113 minimalBlockLength(version);
9114 }
9115
9117 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9118 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9119 constexpr
9120 static
9121 MessageSize
9129
9131 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9132 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9133 constexpr
9134 static StrRef className()
9135 noexcept
9136 {
9137 return constructStrRef("BfInstrumentReference");
9138 }
9139
9141 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9142 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9143 constexpr
9144 static StrRef fixType()
9145 noexcept
9146 {
9147 return constructStrRef("BFInstrumentReference");
9148 }
9149
9151 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9152 std::string toString() const;
9153
9154private:
9155 void checkLength(
9156 EncodedLength length, SchemaVersion version) const
9157 {
9158 const EncodedLength minimalRequiredLength =
9159 minimalBlockLength(version) +
9160 MessageHeader::Size +
9161 getMinimalVariableFieldsSize(version);
9162
9163 checkBinaryLength(
9164 *this, length, minimalRequiredLength);
9165 }
9166
9168 void checkVarLenFields() const
9169 {
9170 groups().
9171 checkTail<InterestPaymentDateRep>();
9172 }
9173
9174 void checkCompatibility() const
9175 {
9176 assert(TemplateId == templateId());
9177
9178 checkSchema<Schema>(schemaId(), version());
9179 checkLength(bufferSize(), version());
9180 checkVarLenFields();
9181 }
9182
9184 struct InterestPaymentDateRepAccess
9185 {
9186 InterestPaymentDateRep
9187 operator()(
9188 const BfInstrumentReference& obj) const
9189 noexcept
9190 {
9191 return obj.
9192 groups().
9193 head<InterestPaymentDateRep>();
9194 }
9195 };
9196};
9197
9199ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
9200BfTrade
9201: SbeMessage
9202{
9204 typedef SchemaTraits Schema;
9205
9207 enum { TemplateId = 1202 };
9208
9210 BfTrade() =default;
9211
9213 BfTrade(
9214 const void* data,
9215 EncodedLength length)
9216 : SbeMessage(data, length)
9217 {
9218 checkCompatibility();
9219 }
9220
9222 explicit
9223 BfTrade(
9224 const SbeMessage& message)
9225 : SbeMessage(message)
9226 {
9227 assert(message.valid());
9228
9229 checkCompatibility();
9230 }
9231
9233 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9234 bool seqNum(Uint64& value) const
9235 noexcept
9236 {
9237 constexpr BlockLength offset = 0;
9238
9239 return ordinary(value, offset, NullUint64());
9240 }
9241
9243 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9244 bool rebroadcastIndicator(UnsignedChar& value) const
9245 noexcept
9246 {
9247 constexpr BlockLength offset = 8;
9248
9249 return ordinary(value, offset, NullUnsignedChar());
9250 }
9251
9253 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9254 bool symbolIndex(Uint32& value) const
9255 noexcept
9256 {
9257 constexpr BlockLength offset = 9;
9258
9259 return ordinary(value, offset, NullUint32());
9260 }
9261
9263 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9264 StrRef miFIdTransactionId() const
9265 noexcept
9266 {
9267 constexpr BlockLength offset = 13;
9268 constexpr BlockLength length = 52;
9269
9270 return fixedStr<length>(offset);
9271 }
9272
9274 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9275 bool eventTime(Uint64& value) const
9276 noexcept
9277 {
9278 constexpr BlockLength offset = 65;
9279
9280 return ordinary(value, offset, NullUint64());
9281 }
9282
9284 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9285 bool bidOfferDateTime(Uint64& value) const
9286 noexcept
9287 {
9288 constexpr BlockLength offset = 73;
9289
9290 return ordinary(value, offset, NullUint64());
9291 }
9292
9294 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9295 StrRef mMTModificationIndicator() const
9296 noexcept
9297 {
9298 constexpr BlockLength offset = 81;
9299 constexpr BlockLength length = 4;
9300
9301 return fixedStr<length>(offset);
9302 }
9303
9305 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9306 bool price(Int64& value) const
9307 noexcept
9308 {
9309 constexpr BlockLength offset = 85;
9310
9311 return ordinary(value, offset, NullInt64());
9312 }
9313
9315 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9316 bool bidPrice(Int64& value) const
9317 noexcept
9318 {
9319 constexpr BlockLength offset = 93;
9320
9321 return ordinary(value, offset, NullInt64());
9322 }
9323
9325 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9326 bool offerPrice(Int64& value) const
9327 noexcept
9328 {
9329 constexpr BlockLength offset = 101;
9330
9331 return ordinary(value, offset, NullInt64());
9332 }
9333
9335 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9336 bool quantity(Uint64& value) const
9337 noexcept
9338 {
9339 constexpr BlockLength offset = 109;
9340
9341 return ordinary(value, offset, NullUint64());
9342 }
9343
9345 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9346 bool mMTAgencyCrossTradeIndicator(StrRef& value) const
9347 noexcept
9348 {
9349 constexpr BlockLength offset = 117;
9350 constexpr BlockLength length = 4;
9351
9352 return fixedStr<length>(value, offset);
9353 }
9354
9356 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9357 bool mMTBenchmarkIndicator(StrRef& value) const
9358 noexcept
9359 {
9360 constexpr BlockLength offset = 121;
9361 constexpr BlockLength length = 4;
9362
9363 return fixedStr<length>(value, offset);
9364 }
9365
9367 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9368 bool mMTSpecialDividendIndicator(StrRef& value) const
9369 noexcept
9370 {
9371 constexpr BlockLength offset = 125;
9372 constexpr BlockLength length = 4;
9373
9374 return fixedStr<length>(value, offset);
9375 }
9376
9378 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9379 bool
9380 mMTTradingMode(
9381 MmtTradingMode::Enum& value) const
9382 noexcept
9383 {
9384 constexpr BlockLength offset = 129;
9385
9386 return enumeration<MmtTradingMode>(value, offset, NullChar());
9387 }
9388
9390 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9391 bool miFIdPriceNotation(StrRef& value) const
9392 noexcept
9393 {
9394 constexpr BlockLength offset = 130;
9395 constexpr BlockLength length = 4;
9396
9397 return fixedStr<length>(value, offset);
9398 }
9399
9401 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9402 bool quantityNotation(StrRef& value) const
9403 noexcept
9404 {
9405 constexpr BlockLength offset = 134;
9406 constexpr BlockLength length = 3;
9407
9408 return fixedStr<length>(value, offset);
9409 }
9410
9412 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9413 bool notionalAmountTraded(Int64& value) const
9414 noexcept
9415 {
9416 constexpr BlockLength offset = 137;
9417
9418 return ordinary(value, offset, NullInt64());
9419 }
9420
9422 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9423 bool tradingCurrency(StrRef& value) const
9424 noexcept
9425 {
9426 constexpr BlockLength offset = 145;
9427 constexpr BlockLength length = 3;
9428
9429 return fixedStr<length>(value, offset);
9430 }
9431
9433 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9434 constexpr
9435 static
9436 BlockLength
9437 minimalBlockLength(
9438 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9439 noexcept
9440 {
9441 return
9442 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9443 148;
9444 }
9445
9447 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9448 constexpr
9449 static BlockLength blockLength(SchemaVersion version)
9450 noexcept
9451 {
9452 return
9453 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9454 minimalBlockLength(version);
9455 }
9456
9458 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9459 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9460 constexpr
9461 static
9462 MessageSize
9463 getMinimalVariableFieldsSize(
9464 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9465 {
9466 return
9467 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9468 0;
9469 }
9470
9472 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9473 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9474 constexpr
9475 static StrRef className()
9476 noexcept
9477 {
9478 return constructStrRef("BfTrade");
9479 }
9480
9482 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9483 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9484 constexpr
9485 static StrRef fixType()
9486 noexcept
9487 {
9488 return constructStrRef("BFTrade");
9489 }
9490
9492 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9493 std::string toString() const;
9494
9495private:
9496 void checkLength(
9497 EncodedLength length, SchemaVersion version) const
9498 {
9499 const EncodedLength minimalRequiredLength =
9500 minimalBlockLength(version) +
9501 MessageHeader::Size +
9502 getMinimalVariableFieldsSize(version);
9503
9504 checkBinaryLength(
9505 *this, length, minimalRequiredLength);
9506 }
9507
9508 void checkCompatibility() const
9509 {
9510 assert(TemplateId == templateId());
9511
9512 checkSchema<Schema>(schemaId(), version());
9513 checkLength(bufferSize(), version());
9514 }
9515};
9516
9518ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
9519Bfnav
9520: SbeMessage
9521{
9523 typedef SchemaTraits Schema;
9524
9526 enum { TemplateId = 1203 };
9527
9529 Bfnav() =default;
9530
9532 Bfnav(
9533 const void* data,
9534 EncodedLength length)
9535 : SbeMessage(data, length)
9536 {
9537 checkCompatibility();
9538 }
9539
9541 explicit
9542 Bfnav(
9543 const SbeMessage& message)
9544 : SbeMessage(message)
9545 {
9546 assert(message.valid());
9547
9548 checkCompatibility();
9549 }
9550
9552 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9553 bool seqNum(Uint64& value) const
9554 noexcept
9555 {
9556 constexpr BlockLength offset = 0;
9557
9558 return ordinary(value, offset, NullUint64());
9559 }
9560
9562 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9563 bool rebroadcastIndicator(UnsignedChar& value) const
9564 noexcept
9565 {
9566 constexpr BlockLength offset = 8;
9567
9568 return ordinary(value, offset, NullUnsignedChar());
9569 }
9570
9572 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9573 bool symbolIndex(Uint32& value) const
9574 noexcept
9575 {
9576 constexpr BlockLength offset = 9;
9577
9578 return ordinary(value, offset, NullUint32());
9579 }
9580
9582 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9583 bool bidOfferDateTime(Uint64& value) const
9584 noexcept
9585 {
9586 constexpr BlockLength offset = 13;
9587
9588 return ordinary(value, offset, NullUint64());
9589 }
9590
9592 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9593 StrRef miFIdTransactionId() const
9594 noexcept
9595 {
9596 constexpr BlockLength offset = 21;
9597 constexpr BlockLength length = 52;
9598
9599 return fixedStr<length>(offset);
9600 }
9601
9603 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9604 StrRef mMTModificationIndicator() const
9605 noexcept
9606 {
9607 constexpr BlockLength offset = 73;
9608 constexpr BlockLength length = 4;
9609
9610 return fixedStr<length>(offset);
9611 }
9612
9614 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9615 bool nAVPrice(Int64& value) const
9616 noexcept
9617 {
9618 constexpr BlockLength offset = 77;
9619
9620 return ordinary(value, offset, NullInt64());
9621 }
9622
9624 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9625 bool eventTime(Uint64& value) const
9626 noexcept
9627 {
9628 constexpr BlockLength offset = 85;
9629
9630 return ordinary(value, offset, NullUint64());
9631 }
9632
9634 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9635 bool nAVBidPrice(Int64& value) const
9636 noexcept
9637 {
9638 constexpr BlockLength offset = 93;
9639
9640 return ordinary(value, offset, NullInt64());
9641 }
9642
9644 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9645 bool nAVOfferPrice(Int64& value) const
9646 noexcept
9647 {
9648 constexpr BlockLength offset = 101;
9649
9650 return ordinary(value, offset, NullInt64());
9651 }
9652
9654 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9655 constexpr
9656 static
9657 BlockLength
9658 minimalBlockLength(
9659 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9660 noexcept
9661 {
9662 return
9663 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9664 109;
9665 }
9666
9668 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9669 constexpr
9670 static BlockLength blockLength(SchemaVersion version)
9671 noexcept
9672 {
9673 return
9674 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9675 minimalBlockLength(version);
9676 }
9677
9679 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9680 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9681 constexpr
9682 static
9683 MessageSize
9684 getMinimalVariableFieldsSize(
9685 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9686 {
9687 return
9688 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9689 0;
9690 }
9691
9693 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9694 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9695 constexpr
9696 static StrRef className()
9697 noexcept
9698 {
9699 return constructStrRef("Bfnav");
9700 }
9701
9703 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9704 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9705 constexpr
9706 static StrRef fixType()
9707 noexcept
9708 {
9709 return constructStrRef("BFNAV");
9710 }
9711
9713 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9714 std::string toString() const;
9715
9716private:
9717 void checkLength(
9718 EncodedLength length, SchemaVersion version) const
9719 {
9720 const EncodedLength minimalRequiredLength =
9721 minimalBlockLength(version) +
9722 MessageHeader::Size +
9723 getMinimalVariableFieldsSize(version);
9724
9725 checkBinaryLength(
9726 *this, length, minimalRequiredLength);
9727 }
9728
9729 void checkCompatibility() const
9730 {
9731 assert(TemplateId == templateId());
9732
9733 checkSchema<Schema>(schemaId(), version());
9734 checkLength(bufferSize(), version());
9735 }
9736};
9737
9739ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
9740BfInstrumentSuspension
9741: SbeMessage
9742{
9744 typedef SchemaTraits Schema;
9745
9747 enum { TemplateId = 1204 };
9748
9750 BfInstrumentSuspension() =default;
9751
9753 BfInstrumentSuspension(
9754 const void* data,
9755 EncodedLength length)
9756 : SbeMessage(data, length)
9757 {
9758 checkCompatibility();
9759 }
9760
9762 explicit
9763 BfInstrumentSuspension(
9764 const SbeMessage& message)
9765 : SbeMessage(message)
9766 {
9767 assert(message.valid());
9768
9769 checkCompatibility();
9770 }
9771
9773 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9774 bool seqNum(Uint64& value) const
9775 noexcept
9776 {
9777 constexpr BlockLength offset = 0;
9778
9779 return ordinary(value, offset, NullUint64());
9780 }
9781
9783 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9784 bool rebroadcastIndicator(UnsignedChar& value) const
9785 noexcept
9786 {
9787 constexpr BlockLength offset = 8;
9788
9789 return ordinary(value, offset, NullUnsignedChar());
9790 }
9791
9793 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9794 bool symbolIndex(Uint32& value) const
9795 noexcept
9796 {
9797 constexpr BlockLength offset = 9;
9798
9799 return ordinary(value, offset, NullUint32());
9800 }
9801
9803 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9804 bool eventTime(Uint64& value) const
9805 noexcept
9806 {
9807 constexpr BlockLength offset = 13;
9808
9809 return ordinary(value, offset, NullUint64());
9810 }
9811
9813 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9814 bool
9815 securityCondition(
9816 SecurityCondition::Enum& value) const
9817 noexcept
9818 {
9819 constexpr BlockLength offset = 21;
9820
9821 return enumeration<SecurityCondition>(value, offset, NullChar());
9822 }
9823
9825 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9826 constexpr
9827 static
9828 BlockLength
9829 minimalBlockLength(
9830 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9831 noexcept
9832 {
9833 return
9834 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9835 22;
9836 }
9837
9839 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9840 constexpr
9841 static BlockLength blockLength(SchemaVersion version)
9842 noexcept
9843 {
9844 return
9845 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9846 minimalBlockLength(version);
9847 }
9848
9850 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9851 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9852 constexpr
9853 static
9854 MessageSize
9855 getMinimalVariableFieldsSize(
9856 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9857 {
9858 return
9859 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9860 0;
9861 }
9862
9864 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9865 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9866 constexpr
9867 static StrRef className()
9868 noexcept
9869 {
9870 return constructStrRef("BfInstrumentSuspension");
9871 }
9872
9874 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9875 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9876 constexpr
9877 static StrRef fixType()
9878 noexcept
9879 {
9880 return constructStrRef("BFInstrumentSuspension");
9881 }
9882
9884 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9885 std::string toString() const;
9886
9887private:
9888 void checkLength(
9889 EncodedLength length, SchemaVersion version) const
9890 {
9891 const EncodedLength minimalRequiredLength =
9892 minimalBlockLength(version) +
9893 MessageHeader::Size +
9894 getMinimalVariableFieldsSize(version);
9895
9896 checkBinaryLength(
9897 *this, length, minimalRequiredLength);
9898 }
9899
9900 void checkCompatibility() const
9901 {
9902 assert(TemplateId == templateId());
9903
9904 checkSchema<Schema>(schemaId(), version());
9905 checkLength(bufferSize(), version());
9906 }
9907};
9908
9910ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
9911StartOfSnapshot
9912: SbeMessage
9913{
9915 typedef SchemaTraits Schema;
9916
9918 enum { TemplateId = 2101 };
9919
9921 StartOfSnapshot() =default;
9922
9924 StartOfSnapshot(
9925 const void* data,
9926 EncodedLength length)
9927 : SbeMessage(data, length)
9928 {
9929 checkCompatibility();
9930 }
9931
9933 explicit
9934 StartOfSnapshot(
9935 const SbeMessage& message)
9936 : SbeMessage(message)
9937 {
9938 assert(message.valid());
9939
9940 checkCompatibility();
9941 }
9942
9944 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9945 bool lastMDSeqNum(Uint64& value) const
9946 noexcept
9947 {
9948 constexpr BlockLength offset = 0;
9949
9950 return ordinary(value, offset, NullUint64());
9951 }
9952
9954 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9955 bool snapshotTime(Uint64& value) const
9956 noexcept
9957 {
9958 constexpr BlockLength offset = 8;
9959
9960 return ordinary(value, offset, NullUint64());
9961 }
9962
9964 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9965 constexpr
9966 static
9967 BlockLength
9968 minimalBlockLength(
9969 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9970 noexcept
9971 {
9972 return
9973 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9974 16;
9975 }
9976
9978 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9979 constexpr
9980 static BlockLength blockLength(SchemaVersion version)
9981 noexcept
9982 {
9983 return
9984 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9985 minimalBlockLength(version);
9986 }
9987
9989 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9990 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9991 constexpr
9992 static
9993 MessageSize
9994 getMinimalVariableFieldsSize(
9995 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9996 {
9997 return
9998 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9999 0;
10000 }
10001
10003 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10004 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10005 constexpr
10006 static StrRef className()
10007 noexcept
10008 {
10009 return constructStrRef("StartOfSnapshot");
10010 }
10011
10013 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10014 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10015 constexpr
10016 static StrRef fixType()
10017 noexcept
10018 {
10019 return constructStrRef("StartOfSnapshot");
10020 }
10021
10023 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10024 std::string toString() const;
10025
10026private:
10027 void checkLength(
10028 EncodedLength length, SchemaVersion version) const
10029 {
10030 const EncodedLength minimalRequiredLength =
10031 minimalBlockLength(version) +
10032 MessageHeader::Size +
10033 getMinimalVariableFieldsSize(version);
10034
10035 checkBinaryLength(
10036 *this, length, minimalRequiredLength);
10037 }
10038
10039 void checkCompatibility() const
10040 {
10041 assert(TemplateId == templateId());
10042
10043 checkSchema<Schema>(schemaId(), version());
10044 checkLength(bufferSize(), version());
10045 }
10046};
10047
10049ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
10050EndOfSnapshot
10051: SbeMessage
10052{
10054 typedef SchemaTraits Schema;
10055
10057 enum { TemplateId = 2102 };
10058
10060 EndOfSnapshot() =default;
10061
10063 EndOfSnapshot(
10064 const void* data,
10065 EncodedLength length)
10066 : SbeMessage(data, length)
10067 {
10068 checkCompatibility();
10069 }
10070
10072 explicit
10073 EndOfSnapshot(
10074 const SbeMessage& message)
10075 : SbeMessage(message)
10076 {
10077 assert(message.valid());
10078
10079 checkCompatibility();
10080 }
10081
10083 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10084 bool lastMDSeqNum(Uint64& value) const
10085 noexcept
10086 {
10087 constexpr BlockLength offset = 0;
10088
10089 return ordinary(value, offset, NullUint64());
10090 }
10091
10093 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10094 bool snapshotTime(Uint64& value) const
10095 noexcept
10096 {
10097 constexpr BlockLength offset = 8;
10098
10099 return ordinary(value, offset, NullUint64());
10100 }
10101
10103 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10104 constexpr
10105 static
10106 BlockLength
10107 minimalBlockLength(
10108 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
10109 noexcept
10110 {
10111 return
10112 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10113 16;
10114 }
10115
10117 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10118 constexpr
10119 static BlockLength blockLength(SchemaVersion version)
10120 noexcept
10121 {
10122 return
10123 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10124 minimalBlockLength(version);
10125 }
10126
10128 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10129 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10130 constexpr
10131 static
10132 MessageSize
10133 getMinimalVariableFieldsSize(
10134 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
10135 {
10136 return
10137 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10138 0;
10139 }
10140
10142 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10143 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10144 constexpr
10145 static StrRef className()
10146 noexcept
10147 {
10148 return constructStrRef("EndOfSnapshot");
10149 }
10150
10152 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10153 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10154 constexpr
10155 static StrRef fixType()
10156 noexcept
10157 {
10158 return constructStrRef("EndOfSnapshot");
10159 }
10160
10162 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10163 std::string toString() const;
10164
10165private:
10166 void checkLength(
10167 EncodedLength length, SchemaVersion version) const
10168 {
10169 const EncodedLength minimalRequiredLength =
10170 minimalBlockLength(version) +
10171 MessageHeader::Size +
10172 getMinimalVariableFieldsSize(version);
10173
10174 checkBinaryLength(
10175 *this, length, minimalRequiredLength);
10176 }
10177
10178 void checkCompatibility() const
10179 {
10180 assert(TemplateId == templateId());
10181
10182 checkSchema<Schema>(schemaId(), version());
10183 checkLength(bufferSize(), version());
10184 }
10185};
10186
10187
10188ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_END
ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_BEGIN
#define ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_BEGIN
Definition ABI.h:146
ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_END
#define ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_END
Definition ABI.h:151
ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
#define ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
Definition ABI.h:94
ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
#define ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
Definition ABI.h:98
ONIXS_EURONEXT_OPTIQMDG_NODISCARD
#define ONIXS_EURONEXT_OPTIQMDG_NODISCARD
Definition Compiler.h:119
ONIXS_EURONEXT_OPTIQMDG_UNUSED
#define ONIXS_EURONEXT_OPTIQMDG_UNUSED
Definition Compiler.h:130
OnixS::Euronext::MarketData::OptiqMdg::Messaging::SbeMessage::getGroup
Group getGroup(Callable callable, Owner &owner) const noexcept
Definition SbeMessage.h:941
OnixS::Euronext::MarketData::OptiqMdg::Messaging::SbeMessage::EncodedLength
MessageSize EncodedLength
Length of the message binary data.
Definition SbeMessage.h:803
OnixS::Euronext::MarketData::OptiqMdg::Messaging::SbeMessage::SbeMessage
SbeMessage() noexcept
Initializes a blank instance.
Definition SbeMessage.h:809
OnixS::Euronext::MarketData::OptiqMdg::Messaging::SbeMessage::BlockLength
MessageSize BlockLength
Length of the message body representing a block of fixed-length fields.
Definition SbeMessage.h:806
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Uint64
UInt64 Uint64
Type alias for the Uint64_t.
Definition Fields.h:45
OnixS::Euronext::MarketData::OptiqMdg::Messaging::constructStrRef
constexpr StrRef constructStrRef(const char(&value)[Size]) noexcept
Definition StrRef.h:415
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Int8
Int8 Int8
Type alias for the Int8_t.
Definition Fields.h:33
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullInt8
IntegralConstant< Int8, -128 > NullInt8
Null value for an optional Int8 field.
Definition Fields.h:4800
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Int64
Int64 Int64
Type alias for the Int64_t.
Definition Fields.h:53
OnixS::Euronext::MarketData::OptiqMdg::Messaging::UnsignedChar
UInt8 UnsignedChar
Type alias for the Unsigned_char.
Definition Fields.h:29
OnixS::Euronext::MarketData::OptiqMdg::Messaging::SchemaVersion
MessageHeader::Version SchemaVersion
SBE-encoded data version type.
Definition SchemaTraits.h:30
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUInt8
IntegralConstant< UInt8, 255 > NullUInt8
Definition Fields.h:4842
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUint16
IntegralConstant< UInt16, 65535 > NullUint16
Null value for an optional Uint16 field.
Definition Fields.h:4806
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullInt64
IntegralConstant< Int64, -9223372036854775807LL-1 > NullInt64
Null value for an optional Int64 field.
Definition Fields.h:4830
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MessageSize
UInt16 MessageSize
Message length type.
Definition Aliases.h:29
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Uint16
UInt16 Uint16
Type alias for the Uint16_t.
Definition Fields.h:37
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullChar
IntegralConstant< Char, -128 > NullChar
Definition Fields.h:4846
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUint64
IntegralConstant< UInt64, 18446744073709551615ULL > NullUint64
Null value for an optional Uint64 field.
Definition Fields.h:4818
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUnsignedChar
IntegralConstant< UInt8, 255 > NullUnsignedChar
Null value for an optional UnsignedChar field.
Definition Fields.h:4794
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Uint32
UInt32 Uint32
Type alias for the Uint32_t.
Definition Fields.h:41
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUInt64
IntegralConstant< UInt64, 18446744073709551615ULL > NullUInt64
Definition Fields.h:4850
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUint32
IntegralConstant< UInt32, 4294967295 > NullUint32
Null value for an optional Uint32 field.
Definition Fields.h:4812
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdQtyinMsrmtUnitNotation
bool miFIdQtyinMsrmtUnitNotation(StrRef &value) const noexcept
Provides access to miFIDQtyinMsrmtUnitNotation field.
Definition Messages.h:8151
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTModificationIndicator
bool efficientMMTModificationIndicator(EfficientMMTModificationIndicator::Enum &value) const noexcept
Provides access to efficientMMTModificationIndicator field.
Definition Messages.h:8267
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTMarketMechanism
bool efficientMMTMarketMechanism(EfficientMMTMarketMechanism::Enum &value) const noexcept
Provides access to efficientMMTMarketMechanism field.
Definition Messages.h:8207
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::ApaFullTradeInformation
ApaFullTradeInformation(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7991
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidPrice
bool mifidPrice(StrRef &value) const noexcept
Provides access to mifidPrice field.
Definition Messages.h:8107
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::priceMultiplierDecimals
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition Messages.h:8405
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:8472
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:8002
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTAgencyCrossTradeIndicator
bool efficientMMTAgencyCrossTradeIndicator(EfficientMMTAgencyCrossTradeIndicator::Enum &value) const noexcept
Provides access to efficientMMTAgencyCrossTradeIndicator field.
Definition Messages.h:8255
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidQuantity
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition Messages.h:8118
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::ApaFullTradeInformation
ApaFullTradeInformation(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:7981
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:8032
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:8012
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::priceMultiplier
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition Messages.h:8395
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTTransactionCategory
bool efficientMMTTransactionCategory(EfficientMMTTransactionCategory::Enum &value) const noexcept
Provides access to efficientMMTTransactionCategory field.
Definition Messages.h:8231
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTAlgorithmicIndicator
bool efficientMMTAlgorithmicIndicator(EfficientMMTAlgorithmicIndicator::Enum &value) const noexcept
Provides access to efficientMMTAlgorithmicIndicator field.
Definition Messages.h:8327
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::longTradeReference
bool longTradeReference(StrRef &value) const noexcept
Provides access to longTradeReference field.
Definition Messages.h:8437
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTSpecialDividendIndicator
bool efficientMMTSpecialDividendIndicator(EfficientMMTSpecialDividendIndicator::Enum &value) const noexcept
Provides access to efficientMMTSpecialDividendIndicator field.
Definition Messages.h:8291
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::tradeReference
bool tradeReference(StrRef &value) const noexcept
Provides access to tradeReference field.
Definition Messages.h:8374
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTPublicationMode
bool efficientMMTPublicationMode(EfficientMMTPublicationMode::Enum &value) const noexcept
Provides access to efficientMMTPublicationMode field.
Definition Messages.h:8339
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::venue
StrRef venue() const noexcept
Provides access to venue field.
Definition Messages.h:8415
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidPriceNotation
bool mifidPriceNotation(StrRef &value) const noexcept
Provides access to mifidPriceNotation field.
Definition Messages.h:8129
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidCurrency
bool mifidCurrency(StrRef &value) const noexcept
Provides access to mifidCurrency field.
Definition Messages.h:8140
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdClearingFlag
bool miFIdClearingFlag(StrRef &value) const noexcept
Provides access to miFIDClearingFlag field.
Definition Messages.h:8195
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::notionalCurrency
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition Messages.h:8184
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:8499
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidInstrumentIdType
bool mifidInstrumentIdType(StrRef &value) const noexcept
Provides access to mifidInstrumentIdType field.
Definition Messages.h:8074
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTDuplicativeIndicator
bool efficientMMTDuplicativeIndicator(EfficientMMTDuplicativeIndicator::Enum &value) const noexcept
Provides access to efficientMMTDuplicativeIndicator field.
Definition Messages.h:8363
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:8485
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidQuantityMeasurementUnit
bool mifidQuantityMeasurementUnit(StrRef &value) const noexcept
Provides access to mifidQuantityMeasurementUnit field.
Definition Messages.h:8162
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTBenchmarkIndicator
bool efficientMMTBenchmarkIndicator(EfficientMMTBenchmarkIndicator::Enum &value) const noexcept
Provides access to efficientMMTBenchmarkIndicator field.
Definition Messages.h:8279
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::publicationDateTime
bool publicationDateTime(StrRef &value) const noexcept
Provides access to publicationDateTime field.
Definition Messages.h:8053
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:8521
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTOffBookAutomatedIndicator
bool efficientMMTOffBookAutomatedIndicator(EfficientMMTOffBookAutomatedIndicator::Enum &value) const noexcept
Provides access to efficientMMTOffBookAutomatedIndicator field.
Definition Messages.h:8303
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdTransactionId
StrRef miFIdTransactionId() const noexcept
Provides access to miFIDTransactionID field.
Definition Messages.h:8096
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::tradeType
TradeType::Enum tradeType() const noexcept
Provides access to tradeType field.
Definition Messages.h:8064
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::originalReportTimestamp
bool originalReportTimestamp(Uint64 &value) const noexcept
Provides access to originalReportTimestamp field.
Definition Messages.h:8385
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTTradingMode
bool efficientMMTTradingMode(EfficientMMTTradingMode::Enum &value) const noexcept
Provides access to efficientMMTTradingMode field.
Definition Messages.h:8219
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTPostTradeDeferral
bool efficientMMTPostTradeDeferral(EfficientMMTPostTradeDeferral::Enum &value) const noexcept
Provides access to efficientMMTPostTradeDeferral field.
Definition Messages.h:8351
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:8022
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::tradeUniqueIdentifier
bool tradeUniqueIdentifier(StrRef &value) const noexcept
Provides access to tradeUniqueIdentifier field.
Definition Messages.h:8459
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdEmissionAllowanceType
bool miFIdEmissionAllowanceType(StrRef &value) const noexcept
Provides access to miFIDEmissionAllowanceType field.
Definition Messages.h:8426
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidInstrumentId
bool mifidInstrumentId(StrRef &value) const noexcept
Provides access to mifidInstrumentID field.
Definition Messages.h:8085
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTNegotiationIndicator
bool efficientMMTNegotiationIndicator(EfficientMMTNegotiationIndicator::Enum &value) const noexcept
Provides access to efficientMMTNegotiationIndicator field.
Definition Messages.h:8243
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::aPAOrigin
bool aPAOrigin(StrRef &value) const noexcept
Provides access to aPAOrigin field.
Definition Messages.h:8448
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::tradingDateTime
StrRef tradingDateTime() const noexcept
Provides access to tradingDateTime field.
Definition Messages.h:8042
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdNotionalAmount
bool miFIdNotionalAmount(StrRef &value) const noexcept
Provides access to miFIDNotionalAmount field.
Definition Messages.h:8173
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTContributiontoPrice
bool efficientMMTContributiontoPrice(EfficientMMTContributiontoPrice::Enum &value) const noexcept
Provides access to efficientMMTContributiontoPrice field.
Definition Messages.h:8315
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mifidPrice
StrRef mifidPrice() const noexcept
Provides access to mifidPrice field.
Definition Messages.h:7518
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::ApaQuotes
ApaQuotes(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7412
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7554
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:7423
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mifidQuantity
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition Messages.h:7529
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:7498
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:7433
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mifidInstrumentId
StrRef mifidInstrumentId() const noexcept
Provides access to mifidInstrumentID field.
Definition Messages.h:7454
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mIC
StrRef mIC() const noexcept
Provides access to mIC field.
Definition Messages.h:7465
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mifidInstrumentIdType
StrRef mifidInstrumentIdType() const noexcept
Provides access to mifidInstrumentIdType field.
Definition Messages.h:7443
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::ApaQuotes
ApaQuotes(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:7402
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::lEICode
StrRef lEICode() const noexcept
Provides access to lEICode field.
Definition Messages.h:7487
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::ApaQuotes
ApaQuotes()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::quoteUpdateType
QuoteUpdateType::Enum quoteUpdateType() const noexcept
Provides access to quoteUpdateType field.
Definition Messages.h:7508
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:7580
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7566
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7602
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::currency
StrRef currency() const noexcept
Provides access to currency field.
Definition Messages.h:7476
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::aPAOrigin
bool aPAOrigin(StrRef &value) const noexcept
Provides access to aPAOrigin field.
Definition Messages.h:7540
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::priceMultiplierDecimals
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition Messages.h:7766
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7886
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:7670
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::optionType
bool optionType(OptionType::Enum &value) const noexcept
Provides access to optionType field.
Definition Messages.h:7809
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:7680
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::priceMultiplier
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition Messages.h:7756
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::mifidInstrumentId
StrRef mifidInstrumentId() const noexcept
Provides access to mifidInstrumentID field.
Definition Messages.h:7701
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::mifidInstrumentIdType
StrRef mifidInstrumentIdType() const noexcept
Provides access to mifidInstrumentIdType field.
Definition Messages.h:7690
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::maturityDate
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition Messages.h:7851
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::cFI
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition Messages.h:7723
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::underlyingISINCode
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition Messages.h:7776
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::exerStyle
bool exerStyle(ExerciseStyle::Enum &value) const noexcept
Provides access to exerStyle field.
Definition Messages.h:7840
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::notionalCurrency
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition Messages.h:7734
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:7912
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::secondNotionalCurrency
bool secondNotionalCurrency(StrRef &value) const noexcept
Provides access to secondNotionalCurrency field.
Definition Messages.h:7745
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7898
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7934
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::underlyingIndexTerm
bool underlyingIndexTerm(StrRef &value) const noexcept
Provides access to underlyingIndexTerm field.
Definition Messages.h:7798
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::strikePriceDecimals
bool strikePriceDecimals(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimals field.
Definition Messages.h:7829
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::ApaStandingData
ApaStandingData(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:7649
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::ApaStandingData
ApaStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7659
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::strikePrice
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition Messages.h:7819
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::expiryDate
bool expiryDate(StrRef &value) const noexcept
Provides access to expiryDate field.
Definition Messages.h:7862
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::settlementMethod
bool settlementMethod(Char &value) const noexcept
Provides access to settlementMethod field.
Definition Messages.h:7873
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::fullInstrumentName
bool fullInstrumentName(StrRef &value) const noexcept
Provides access to fullInstrumentName field.
Definition Messages.h:7712
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::underlyingIndexName
bool underlyingIndexName(StrRef &value) const noexcept
Provides access to underlyingIndexName field.
Definition Messages.h:7787
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::InterestPaymentDateRepEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:8621
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::InterestPaymentDateRepEntry::InterestPaymentDateRepEntry
InterestPaymentDateRepEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:8583
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::InterestPaymentDateRepEntry::interestPaymentDate
bool interestPaymentDate(Uint16 &value) const noexcept
Provides access to interestPaymentDate field.
Definition Messages.h:8595
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dividendCurrency
bool dividendCurrency(StrRef &value) const noexcept
Provides access to dividendCurrency field.
Definition Messages.h:8872
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::priceIndexLevelDecimals
bool priceIndexLevelDecimals(UnsignedChar &value) const noexcept
Provides access to priceIndexLevelDecimals field.
Definition Messages.h:9043
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::issueDate
bool issueDate(Uint16 &value) const noexcept
Provides access to issueDate field.
Definition Messages.h:8956
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9096
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:8671
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dividendRecordDate
bool dividendRecordDate(Uint16 &value) const noexcept
Provides access to dividendRecordDate field.
Definition Messages.h:8883
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::BfInstrumentReference
BfInstrumentReference(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:8660
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:8681
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::paymentFrequency
bool paymentFrequency(PaymentFrequency::Enum &value) const noexcept
Provides access to paymentFrequency field.
Definition Messages.h:8989
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::issuingCountry
bool issuingCountry(StrRef &value) const noexcept
Provides access to issuingCountry field.
Definition Messages.h:8966
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::iSINCode
bool iSINCode(StrRef &value) const noexcept
Provides access to iSINCode field.
Definition Messages.h:8711
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::mIC
bool mIC(StrRef &value) const noexcept
Provides access to mIC field.
Definition Messages.h:8851
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::instrumentCategory
InstrumentCategory::Enum instrumentCategory() const noexcept
Provides access to instrumentCategory field.
Definition Messages.h:9010
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dividendPaymentDate
bool dividendPaymentDate(Uint16 &value) const noexcept
Provides access to dividendPaymentDate field.
Definition Messages.h:8913
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::BfInstrumentReference
BfInstrumentReference(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:8650
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::maturityDate
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition Messages.h:8830
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::amountDecimals
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition Messages.h:9063
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::grossDividendPayablePerUnit
bool grossDividendPayablePerUnit(Int64 &value) const noexcept
Provides access to grossDividendPayablePerUnit field.
Definition Messages.h:8862
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::cFI
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition Messages.h:8977
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::grossDividendInEuros
bool grossDividendInEuros(Int64 &value) const noexcept
Provides access to grossDividendInEuros field.
Definition Messages.h:8946
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:8691
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::exDividendDate
bool exDividendDate(Uint16 &value) const noexcept
Provides access to exDividendDate field.
Definition Messages.h:8903
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::closingPrice
bool closingPrice(Int64 &value) const noexcept
Provides access to closingPrice field.
Definition Messages.h:8841
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::longInstrumentName
bool longInstrumentName(StrRef &value) const noexcept
Provides access to longInstrumentName field.
Definition Messages.h:8744
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::coupon
bool coupon(Int64 &value) const noexcept
Provides access to coupon field.
Definition Messages.h:8820
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::sEDOLCode
bool sEDOLCode(StrRef &value) const noexcept
Provides access to sEDOLCode field.
Definition Messages.h:8722
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::optiqSegment
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition Messages.h:8701
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:9122
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dividendRate
bool dividendRate(Uint64 &value) const noexcept
Provides access to dividendRate field.
Definition Messages.h:8893
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::quantityDecimals
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition Messages.h:9053
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::miFIdPriceNotation
bool miFIdPriceNotation(StrRef &value) const noexcept
Provides access to miFIDPriceNotation field.
Definition Messages.h:9032
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9108
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9144
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::shareAmountInIssue
bool shareAmountInIssue(Int64 &value) const noexcept
Provides access to shareAmountInIssue field.
Definition Messages.h:8776
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::longIssuerName
bool longIssuerName(StrRef &value) const noexcept
Provides access to longIssuerName field.
Definition Messages.h:8733
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::minimumAmount
bool minimumAmount(Int64 &value) const noexcept
Provides access to minimumAmount field.
Definition Messages.h:9000
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::lastNAVPrice
bool lastNAVPrice(Int64 &value) const noexcept
Provides access to lastNAVPrice field.
Definition Messages.h:8798
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::nextMeeting
bool nextMeeting(StrRef &value) const noexcept
Provides access to nextMeeting field.
Definition Messages.h:8935
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::openedClosedFund
bool openedClosedFund(OpenedClosedFund::Enum &value) const noexcept
Provides access to openedClosedFund field.
Definition Messages.h:8787
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::InterestPaymentDateRep
SbeGroup< InterestPaymentDateRepEntry, GroupSizeEncoding, MessageSize > InterestPaymentDateRep
Repeating group containing InterestPaymentDateRepEntry entries.
Definition Messages.h:8644
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::currency
bool currency(StrRef &value) const noexcept
Provides access to currency field.
Definition Messages.h:8755
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::grossOfCDSCIndicator
bool grossOfCDSCIndicator(GrossofCDSCIndicator::Enum &value) const noexcept
Provides access to grossOfCDSCIndicator field.
Definition Messages.h:8809
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::ratioMultiplierDecimals
bool ratioMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to ratioMultiplierDecimals field.
Definition Messages.h:9073
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dateOfInitialListing
bool dateOfInitialListing(Uint16 &value) const noexcept
Provides access to dateOfInitialListing field.
Definition Messages.h:8766
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::taxDescriptionAttachingToADividend
bool taxDescriptionAttachingToADividend(TaxDescriptionAttachingtoaDividend::Enum &value) const noexcept
Provides access to taxDescriptionAttachingToADividend field.
Definition Messages.h:8924
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::securityCondition
bool securityCondition(SecurityCondition::Enum &value) const noexcept
Provides access to securityCondition field.
Definition Messages.h:9021
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9829
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:9774
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:9804
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:9784
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:9794
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:9855
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::BfInstrumentSuspension
BfInstrumentSuspension(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:9753
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9841
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9877
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::BfInstrumentSuspension
BfInstrumentSuspension(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:9763
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::securityCondition
bool securityCondition(SecurityCondition::Enum &value) const noexcept
Provides access to securityCondition field.
Definition Messages.h:9815
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::quantity
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition Messages.h:9336
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9437
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:9234
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::BfTrade
BfTrade(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:9213
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:9275
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:9244
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTModificationIndicator
StrRef mMTModificationIndicator() const noexcept
Provides access to mMTModificationIndicator field.
Definition Messages.h:9295
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTSpecialDividendIndicator
bool mMTSpecialDividendIndicator(StrRef &value) const noexcept
Provides access to mMTSpecialDividendIndicator field.
Definition Messages.h:9368
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::tradingCurrency
bool tradingCurrency(StrRef &value) const noexcept
Provides access to tradingCurrency field.
Definition Messages.h:9423
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTAgencyCrossTradeIndicator
bool mMTAgencyCrossTradeIndicator(StrRef &value) const noexcept
Provides access to mMTAgencyCrossTradeIndicator field.
Definition Messages.h:9346
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:9254
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::price
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition Messages.h:9306
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::quantityNotation
bool quantityNotation(StrRef &value) const noexcept
Provides access to quantityNotation field.
Definition Messages.h:9402
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::BfTrade
BfTrade()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::notionalAmountTraded
bool notionalAmountTraded(Int64 &value) const noexcept
Provides access to notionalAmountTraded field.
Definition Messages.h:9413
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:9463
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::BfTrade
BfTrade(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:9223
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::bidOfferDateTime
bool bidOfferDateTime(Uint64 &value) const noexcept
Provides access to bidOfferDateTime field.
Definition Messages.h:9285
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::miFIdPriceNotation
bool miFIdPriceNotation(StrRef &value) const noexcept
Provides access to miFIDPriceNotation field.
Definition Messages.h:9391
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9449
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTTradingMode
bool mMTTradingMode(MmtTradingMode::Enum &value) const noexcept
Provides access to mMTTradingMode field.
Definition Messages.h:9380
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9485
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::bidPrice
bool bidPrice(Int64 &value) const noexcept
Provides access to bidPrice field.
Definition Messages.h:9316
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::miFIdTransactionId
StrRef miFIdTransactionId() const noexcept
Provides access to miFIDTransactionID field.
Definition Messages.h:9264
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTBenchmarkIndicator
bool mMTBenchmarkIndicator(StrRef &value) const noexcept
Provides access to mMTBenchmarkIndicator field.
Definition Messages.h:9357
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::offerPrice
bool offerPrice(Int64 &value) const noexcept
Provides access to offerPrice field.
Definition Messages.h:9326
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9658
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:9553
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:9625
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:9563
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::mMTModificationIndicator
StrRef mMTModificationIndicator() const noexcept
Provides access to mMTModificationIndicator field.
Definition Messages.h:9604
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::nAVOfferPrice
bool nAVOfferPrice(Int64 &value) const noexcept
Provides access to nAVOfferPrice field.
Definition Messages.h:9645
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::nAVPrice
bool nAVPrice(Int64 &value) const noexcept
Provides access to nAVPrice field.
Definition Messages.h:9615
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:9573
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::Bfnav
Bfnav(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:9532
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:9684
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::bidOfferDateTime
bool bidOfferDateTime(Uint64 &value) const noexcept
Provides access to bidOfferDateTime field.
Definition Messages.h:9583
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::className
static constexpr StrRef className() noexcept
Definition Messages.h:9696
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9670
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9706
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::Bfnav
Bfnav()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::miFIdTransactionId
StrRef miFIdTransactionId() const noexcept
Provides access to miFIDTransactionID field.
Definition Messages.h:9593
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::nAVBidPrice
bool nAVBidPrice(Int64 &value) const noexcept
Provides access to nAVBidPrice field.
Definition Messages.h:9635
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::Bfnav
Bfnav(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:9542
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::ContractEMMPropertiesEntry
ContractEMMPropertiesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:5485
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::patternId
bool patternId(Uint16 &value) const noexcept
Provides access to patternID field.
Definition Messages.h:5517
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:5597
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::eMM
bool eMM(Emm::Enum &value) const noexcept
Provides access to eMM field.
Definition Messages.h:5497
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::dynamicCollarLogic
bool dynamicCollarLogic(DynamicCollarLogic::Enum &value) const noexcept
Provides access to dynamicCollarLogic field.
Definition Messages.h:5550
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::lotSize
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition Messages.h:5527
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::collarUnhaltDelay
bool collarUnhaltDelay(Uint32 &value) const noexcept
Provides access to collarUnhaltDelay field.
Definition Messages.h:5571
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::collarMaxUnhaltNb
bool collarMaxUnhaltNb(UnsignedChar &value) const noexcept
Provides access to collarMaxUnhaltNb field.
Definition Messages.h:5561
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::strategyAuthorized
bool strategyAuthorized(StrategyAuthorized &value) const noexcept
Provides access to strategyAuthorized field.
Definition Messages.h:5538
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::tickSizeIndexId
bool tickSizeIndexId(Uint16 &value) const noexcept
Provides access to tickSizeIndexID field.
Definition Messages.h:5507
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::settlementTickSize
bool settlementTickSize(Uint64 &value) const noexcept
Provides access to settlementTickSize field.
Definition Messages.h:5975
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingMIC
bool underlyingMIC(StrRef &value) const noexcept
Provides access to underlyingMIC field.
Definition Messages.h:5846
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::orderTypeRules
OrderTypeRules orderTypeRules() const noexcept
Provides access to orderTypeRules field.
Definition Messages.h:5878
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractStandingData
ContractStandingData(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:5626
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6137
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::priceDecimals
bool priceDecimals(UnsignedChar &value) const noexcept
Provides access to priceDecimals field.
Definition Messages.h:5762
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::lotMultiplier
bool lotMultiplier(Uint64 &value) const noexcept
Provides access to lotMultiplier field.
Definition Messages.h:6115
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:5647
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:5657
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractStandingData
ContractStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:5636
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::contractEventDate
bool contractEventDate(Uint16 &value) const noexcept
Provides access to contractEventDate field.
Definition Messages.h:5697
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::mIC
StrRef mIC() const noexcept
Provides access to mIC field.
Definition Messages.h:5813
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ratioDecimals
bool ratioDecimals(UnsignedChar &value) const noexcept
Provides access to ratioDecimals field.
Definition Messages.h:5792
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::mainDepositary
bool mainDepositary(StrRef &value) const noexcept
Provides access to mainDepositary field.
Definition Messages.h:5802
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::tradingCurrency
StrRef tradingCurrency() const noexcept
Provides access to tradingCurrency field.
Definition Messages.h:5898
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::collarExpansionFactor
bool collarExpansionFactor(UnsignedChar &value) const noexcept
Provides access to collarExpansionFactor field.
Definition Messages.h:6085
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::eDSPTickSize
bool eDSPTickSize(Uint64 &value) const noexcept
Provides access to eDSPTickSize field.
Definition Messages.h:5985
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::contractTradingType
ContractTradingType::Enum contractTradingType() const noexcept
Provides access to contractTradingType field.
Definition Messages.h:5930
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::amountDecimals
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition Messages.h:5782
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingSymbolIndex
bool underlyingSymbolIndex(Uint32 &value) const noexcept
Provides access to underlyingSymbolIndex field.
Definition Messages.h:5995
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingISINCode
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition Messages.h:5857
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::referenceSpreadTableId
bool referenceSpreadTableId(Uint16 &value) const noexcept
Provides access to referenceSpreadTableID field.
Definition Messages.h:6017
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::strikePriceDecimalsRatio
bool strikePriceDecimalsRatio(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimalsRatio field.
Definition Messages.h:5909
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::exerStyle
bool exerStyle(ExerciseStyle::Enum &value) const noexcept
Provides access to exerStyle field.
Definition Messages.h:5718
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::tradingUnit
bool tradingUnit(Uint64 &value) const noexcept
Provides access to tradingUnit field.
Definition Messages.h:6039
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:5667
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::referencePriceOriginInOpeningCall
bool referencePriceOriginInOpeningCall(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInOpeningCall field.
Definition Messages.h:6050
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::instUnitExp
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition Messages.h:5941
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::contractName
StrRef contractName() const noexcept
Provides access to contractName field.
Definition Messages.h:5729
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::optiqSegment
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition Messages.h:5677
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::mMProtections
MmProtections mMProtections() const noexcept
Provides access to mMProtections field.
Definition Messages.h:5919
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:6164
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::quantityDecimals
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition Messages.h:5772
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6150
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingSubtype
bool underlyingSubtype(UnderlyingSubtype::Enum &value) const noexcept
Provides access to underlyingSubtype field.
Definition Messages.h:5953
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:6186
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMProperties
SbeGroup< ContractEMMPropertiesEntry, GroupSizeEncoding, MessageSize > ContractEMMProperties
Repeating group containing ContractEMMPropertiesEntry entries.
Definition Messages.h:5620
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingType
UnderlyingType::Enum underlyingType() const noexcept
Provides access to underlyingType field.
Definition Messages.h:5752
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::tradingPolicy
bool tradingPolicy(TradingPolicy::Enum &value) const noexcept
Provides access to tradingPolicy field.
Definition Messages.h:6006
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::productCode
StrRef productCode() const noexcept
Provides access to productCode field.
Definition Messages.h:5835
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::referencePriceOriginInContinuous
bool referencePriceOriginInContinuous(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInContinuous field.
Definition Messages.h:6062
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::referencePriceOriginInTradingInterruption
bool referencePriceOriginInTradingInterruption(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInTradingInterruption field.
Definition Messages.h:6074
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::mIFIdIILiquidFlag
bool mIFIdIILiquidFlag(UnsignedChar &value) const noexcept
Provides access to mIFIDIILiquidFlag field.
Definition Messages.h:6095
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::exchangeCode
ExchangeCode::Enum exchangeCode() const noexcept
Provides access to exchangeCode field.
Definition Messages.h:5707
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::derivativesMarketModel
bool derivativesMarketModel(DerivativesMarketModel::Enum &value) const noexcept
Provides access to derivativesMarketModel field.
Definition Messages.h:6028
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::partitionId
bool partitionId(Uint16 &value) const noexcept
Provides access to partitionID field.
Definition Messages.h:5687
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::settlementMethod
bool settlementMethod(Char &value) const noexcept
Provides access to settlementMethod field.
Definition Messages.h:5888
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::contractType
bool contractType(ContractType::Enum &value) const noexcept
Provides access to contractType field.
Definition Messages.h:5741
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::pricingAlgorithm
PricingAlgorithm::Enum pricingAlgorithm() const noexcept
Provides access to pricingAlgorithm field.
Definition Messages.h:6105
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::motherStockISIN
bool motherStockISIN(StrRef &value) const noexcept
Provides access to motherStockISIN field.
Definition Messages.h:5964
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::countryOfExchange
StrRef countryOfExchange() const noexcept
Provides access to countryOfExchange field.
Definition Messages.h:5824
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingExpiry
bool underlyingExpiry(Uint32 &value) const noexcept
Provides access to underlyingExpiry field.
Definition Messages.h:5868
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:231
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:208
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::EndOfDay
EndOfDay(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:187
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:257
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:243
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:279
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::EndOfDay
EndOfDay(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:197
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::sessionTradingDay
bool sessionTradingDay(Uint16 &value) const noexcept
Provides access to sessionTradingDay field.
Definition Messages.h:218
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::EndOfDay
EndOfDay()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:10107
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::lastMDSeqNum
bool lastMDSeqNum(Uint64 &value) const noexcept
Provides access to lastMDSeqNum field.
Definition Messages.h:10084
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::EndOfSnapshot
EndOfSnapshot(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:10063
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::EndOfSnapshot
EndOfSnapshot(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:10073
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::snapshotTime
bool snapshotTime(Uint64 &value) const noexcept
Provides access to snapshotTime field.
Definition Messages.h:10094
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:10133
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:10119
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:10155
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::EndOfSnapshot
EndOfSnapshot()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::NotUsedGroup1Entry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:1678
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::NotUsedGroup1Entry::NotUsedGroup1Entry
NotUsedGroup1Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:1650
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::NotUsedGroup1Entry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:1646
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::NotUsedGroup1Entry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1664
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTOffBookAutomatedIndicator
bool mMTOffBookAutomatedIndicator(MmtOffBookAutomatedIndicator::Enum &value) const noexcept
Provides access to mMTOffBookAutomatedIndicator field.
Definition Messages.h:2033
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::miFIdQtyinMsrmtUnitNotation
bool miFIdQtyinMsrmtUnitNotation(StrRef &value) const noexcept
Provides access to miFIDQtyinMsrmtUnitNotation field.
Definition Messages.h:1887
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::evaluatedPrice
bool evaluatedPrice(Int64 &value) const noexcept
Provides access to evaluatedPrice field.
Definition Messages.h:2261
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidPrice
bool mifidPrice(StrRef &value) const noexcept
Provides access to mifidPrice field.
Definition Messages.h:1843
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::priceMultiplierDecimals
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition Messages.h:2198
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:2422
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:1728
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::transparencyIndicator
bool transparencyIndicator(TransparencyIndicator::Enum &value) const noexcept
Provides access to transparencyIndicator field.
Definition Messages.h:2167
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidQuantity
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition Messages.h:1854
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidExecutionId
StrRef mifidExecutionId() const noexcept
Provides access to mifidExecutionID field.
Definition Messages.h:1832
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:1758
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:1738
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::priceMultiplier
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition Messages.h:2188
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::blockTradeCode
bool blockTradeCode(BlockTradeCode::Enum &value) const noexcept
Provides access to blockTradeCode field.
Definition Messages.h:2134
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTSpecialDividendIndicator
bool mMTSpecialDividendIndicator(StrRef &value) const noexcept
Provides access to mMTSpecialDividendIndicator field.
Definition Messages.h:2021
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::venueofPublication
bool venueofPublication(StrRef &value) const noexcept
Provides access to venueofPublication field.
Definition Messages.h:2387
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::marketOfReferenceMIC
bool marketOfReferenceMIC(StrRef &value) const noexcept
Provides access to marketOfReferenceMIC field.
Definition Messages.h:2250
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTAgencyCrossTradeIndicator
bool mMTAgencyCrossTradeIndicator(StrRef &value) const noexcept
Provides access to mMTAgencyCrossTradeIndicator field.
Definition Messages.h:1988
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPublicationModeIlliquid
bool mMTPublicationModeIlliquid(StrRef &value) const noexcept
Provides access to mMTPublicationModeIlliquid field.
Definition Messages.h:2363
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradeReference
bool tradeReference(StrRef &value) const noexcept
Provides access to tradeReference field.
Definition Messages.h:2145
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTDuplicativeIndicator
bool mMTDuplicativeIndicator(StrRef &value) const noexcept
Provides access to mMTDuplicativeIndicator field.
Definition Messages.h:2088
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTContingentTransactionIndicator
bool mMTContingentTransactionIndicator(StrRef &value) const noexcept
Provides access to mMTContingentTransactionIndicator field.
Definition Messages.h:2351
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::venue
StrRef venue() const noexcept
Provides access to venue field.
Definition Messages.h:2208
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:1768
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTModificationIndicator
bool mMTModificationIndicator(StrRef &value) const noexcept
Provides access to mMTModificationIndicator field.
Definition Messages.h:1999
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPreTradeTransparencyWaiverRelatedtoSizeandScale
bool mMTPreTradeTransparencyWaiverRelatedtoSizeandScale(StrRef &value) const noexcept
Provides access to mMTPreTradeTransparencyWaiverRelatedtoSizeandScale field.
Definition Messages.h:2327
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradeQualifier
TradeQualifier tradeQualifier() const noexcept
Provides access to tradeQualifier field.
Definition Messages.h:2099
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidPriceNotation
bool mifidPriceNotation(StrRef &value) const noexcept
Provides access to mifidPriceNotation field.
Definition Messages.h:1865
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::repoSettlementDate
bool repoSettlementDate(Uint16 &value) const noexcept
Provides access to repoSettlementDate field.
Definition Messages.h:2293
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidCurrency
bool mifidCurrency(StrRef &value) const noexcept
Provides access to mifidCurrency field.
Definition Messages.h:1876
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::miFIdClearingFlag
bool miFIdClearingFlag(StrRef &value) const noexcept
Provides access to miFIDClearingFlag field.
Definition Messages.h:1931
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::notionalCurrency
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition Messages.h:1920
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:2453
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidInstrumentIdType
bool mifidInstrumentIdType(StrRef &value) const noexcept
Provides access to mifidInstrumentIdType field.
Definition Messages.h:1810
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:2439
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTTradingMode
bool mMTTradingMode(MmtTradingMode::Enum &value) const noexcept
Provides access to mMTTradingMode field.
Definition Messages.h:1955
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidQuantityMeasurementUnit
bool mifidQuantityMeasurementUnit(StrRef &value) const noexcept
Provides access to mifidQuantityMeasurementUnit field.
Definition Messages.h:1898
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::messagePriceNotation
bool messagePriceNotation(MessagePriceNotation::Enum &value) const noexcept
Provides access to messagePriceNotation field.
Definition Messages.h:2272
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::publicationDateTime
bool publicationDateTime(StrRef &value) const noexcept
Provides access to publicationDateTime field.
Definition Messages.h:1789
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:2475
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPublicationModeSizeSpecific
bool mMTPublicationModeSizeSpecific(StrRef &value) const noexcept
Provides access to mMTPublicationModeSizeSpecific field.
Definition Messages.h:2375
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::settlementDate
bool settlementDate(Uint16 &value) const noexcept
Provides access to settlementDate field.
Definition Messages.h:2283
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::transactionType
bool transactionType(TransactionType::Enum &value) const noexcept
Provides access to transactionType field.
Definition Messages.h:2110
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradeType
TradeType::Enum tradeType() const noexcept
Provides access to tradeType field.
Definition Messages.h:1800
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::missingPrice
bool missingPrice(StrRef &value) const noexcept
Provides access to missingPrice field.
Definition Messages.h:2315
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::originalReportTimestamp
bool originalReportTimestamp(Uint64 &value) const noexcept
Provides access to originalReportTimestamp field.
Definition Messages.h:2156
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTNegotiationIndicator
bool mMTNegotiationIndicator(StrRef &value) const noexcept
Provides access to mMTNegotiationIndicator field.
Definition Messages.h:1977
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPortfolioTransactionIndicator
bool mMTPortfolioTransactionIndicator(StrRef &value) const noexcept
Provides access to mMTPortfolioTransactionIndicator field.
Definition Messages.h:2339
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::effectiveDateIndicator
bool effectiveDateIndicator(EffectiveDateIndicator::Enum &value) const noexcept
Provides access to effectiveDateIndicator field.
Definition Messages.h:2122
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTContributiontoPrice
bool mMTContributiontoPrice(StrRef &value) const noexcept
Provides access to mMTContributiontoPrice field.
Definition Messages.h:2044
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::NotUsedGroup1
SbeGroup< NotUsedGroup1Entry, GroupSizeEncoding, MessageSize > NotUsedGroup1
Repeating group containing NotUsedGroup1Entry entries.
Definition Messages.h:1701
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTAlgorithmicIndicator
bool mMTAlgorithmicIndicator(StrRef &value) const noexcept
Provides access to mMTAlgorithmicIndicator field.
Definition Messages.h:2055
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPublicationMode
bool mMTPublicationMode(StrRef &value) const noexcept
Provides access to mMTPublicationMode field.
Definition Messages.h:2066
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:1748
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTBenchmarkIndicator
bool mMTBenchmarkIndicator(StrRef &value) const noexcept
Provides access to mMTBenchmarkIndicator field.
Definition Messages.h:2010
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPostTradeDeferral
bool mMTPostTradeDeferral(StrRef &value) const noexcept
Provides access to mMTPostTradeDeferral field.
Definition Messages.h:2077
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradeUniqueIdentifier
bool tradeUniqueIdentifier(StrRef &value) const noexcept
Provides access to tradeUniqueIdentifier field.
Definition Messages.h:2303
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::endTimeVwap
bool endTimeVwap(Uint32 &value) const noexcept
Provides access to endTimeVwap field.
Definition Messages.h:2229
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::miFIdEmissionAllowanceType
bool miFIdEmissionAllowanceType(StrRef &value) const noexcept
Provides access to miFIDEmissionAllowanceType field.
Definition Messages.h:2239
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidInstrumentId
bool mifidInstrumentId(StrRef &value) const noexcept
Provides access to mifidInstrumentID field.
Definition Messages.h:1821
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::FullTradeInformation
FullTradeInformation(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:1717
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::startTimeVwap
bool startTimeVwap(Uint32 &value) const noexcept
Provides access to startTimeVwap field.
Definition Messages.h:2219
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::currencyCoefficient
bool currencyCoefficient(Uint32 &value) const noexcept
Provides access to currencyCoefficient field.
Definition Messages.h:2178
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTTransactionCategory
bool mMTTransactionCategory(StrRef &value) const noexcept
Provides access to mMTTransactionCategory field.
Definition Messages.h:1966
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradingDateTime
StrRef tradingDateTime() const noexcept
Provides access to tradingDateTime field.
Definition Messages.h:1778
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTMarketMechanism
bool mMTMarketMechanism(MmtMarketMechanism::Enum &value) const noexcept
Provides access to mMTMarketMechanism field.
Definition Messages.h:1943
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::postTradeDeferralFlags
bool postTradeDeferralFlags(StrRef &value) const noexcept
Provides access to postTradeDeferralFlags field.
Definition Messages.h:2399
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::miFIdNotionalAmount
bool miFIdNotionalAmount(StrRef &value) const noexcept
Provides access to miFIDNotionalAmount field.
Definition Messages.h:1909
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::FullTradeInformation
FullTradeInformation(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:1707
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:370
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::HealthStatus
HealthStatus()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:347
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:357
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::HealthStatus
HealthStatus(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:326
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::HealthStatus
HealthStatus(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:336
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:396
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:382
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:418
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::closingReferenceTime
bool closingReferenceTime(Uint64 &value) const noexcept
Provides access to closingReferenceTime field.
Definition Messages.h:4928
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:5011
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:4828
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:4858
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:4838
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::openingTime
bool openingTime(Uint64 &value) const noexcept
Provides access to openingTime field.
Definition Messages.h:4888
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::prctVarfromPrevClose
bool prctVarfromPrevClose(Int64 &value) const noexcept
Provides access to prctVarfromPrevClose field.
Definition Messages.h:4938
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::highLevel
bool highLevel(Int64 &value) const noexcept
Provides access to highLevel field.
Definition Messages.h:4948
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::openingLevel
bool openingLevel(Int64 &value) const noexcept
Provides access to openingLevel field.
Definition Messages.h:4878
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:4868
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::lowLevel
bool lowLevel(Int64 &value) const noexcept
Provides access to lowLevel field.
Definition Messages.h:4968
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:5037
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5023
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:5059
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::closingReferenceLevel
bool closingReferenceLevel(Int64 &value) const noexcept
Provides access to closingReferenceLevel field.
Definition Messages.h:4918
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::liquidationTime
bool liquidationTime(Uint64 &value) const noexcept
Provides access to liquidationTime field.
Definition Messages.h:4998
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:4848
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::lowTime
bool lowTime(Uint64 &value) const noexcept
Provides access to lowTime field.
Definition Messages.h:4978
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::IndexSummary
IndexSummary(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4817
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::confirmedReferenceTime
bool confirmedReferenceTime(Uint64 &value) const noexcept
Provides access to confirmedReferenceTime field.
Definition Messages.h:4908
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::IndexSummary
IndexSummary(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:4807
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::confirmedReferenceLevel
bool confirmedReferenceLevel(Int64 &value) const noexcept
Provides access to confirmedReferenceLevel field.
Definition Messages.h:4898
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::liquidationLevel
bool liquidationLevel(Int64 &value) const noexcept
Provides access to liquidationLevel field.
Definition Messages.h:4988
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::highTime
bool highTime(Uint64 &value) const noexcept
Provides access to highTime field.
Definition Messages.h:4958
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::IndexSummary
IndexSummary()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::legSymbolIndex
bool legSymbolIndex(Uint32 &value) const noexcept
Provides access to legSymbolIndex field.
Definition Messages.h:7095
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:7151
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::legLastQty
bool legLastQty(Uint64 &value) const noexcept
Provides access to legLastQty field.
Definition Messages.h:7125
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:7079
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::legLastPx
bool legLastPx(Int64 &value) const noexcept
Provides access to legLastPx field.
Definition Messages.h:7115
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::legRatio
bool legRatio(Uint32 &value) const noexcept
Provides access to legRatio field.
Definition Messages.h:7105
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:7137
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::PackageComponentsEntry
PackageComponentsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:7083
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7285
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:7201
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::mifidExecutionId
StrRef mifidExecutionId() const noexcept
Provides access to mifidExecutionID field.
Definition Messages.h:7251
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:7231
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:7211
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::LisPackageStructure
LisPackageStructure(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:7180
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::contractSymbolIndex
bool contractSymbolIndex(Uint32 &value) const noexcept
Provides access to contractSymbolIndex field.
Definition Messages.h:7241
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:7311
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7297
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7333
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:7221
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponents
SbeGroup< PackageComponentsEntry, GroupSizeEncoding, MessageSize > PackageComponents
Repeating group containing PackageComponentsEntry entries.
Definition Messages.h:7174
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::strategyCode
StrategyCode::Enum strategyCode() const noexcept
Provides access to strategyCode field.
Definition Messages.h:7262
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::LisPackageStructure
LisPackageStructure(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7190
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:6851
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::previousPriority
bool previousPriority(Uint64 &value) const noexcept
Provides access to previousPriority field.
Definition Messages.h:6754
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderPx
bool orderPx(Int64 &value) const noexcept
Provides access to orderPx field.
Definition Messages.h:6774
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderQuantity
bool orderQuantity(Uint64 &value) const noexcept
Provides access to orderQuantity field.
Definition Messages.h:6794
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::OrdersEntry
OrdersEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:6711
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderSide
bool orderSide(OrderSide::Enum &value) const noexcept
Provides access to orderSide field.
Definition Messages.h:6784
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::pegOffset
bool pegOffset(Int8 &value) const noexcept
Provides access to pegOffset field.
Definition Messages.h:6804
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:6723
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:6707
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:6864
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:6837
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderType
bool orderType(OrderType::Enum &value) const noexcept
Provides access to orderType field.
Definition Messages.h:6764
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::accountType
AccountType::Enum accountType() const noexcept
Provides access to accountType field.
Definition Messages.h:6825
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::actionType
MarketDataActionType::Enum actionType() const noexcept
Provides access to actionType field.
Definition Messages.h:6734
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::firmId
StrRef firmId() const noexcept
Provides access to firmID field.
Definition Messages.h:6814
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderPriority
bool orderPriority(Uint64 &value) const noexcept
Provides access to orderPriority field.
Definition Messages.h:6744
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6952
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:6901
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:6931
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:6911
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::Orders
SbeGroup< OrdersEntry, GroupSizeEncoding, MessageSize > Orders
Repeating group containing OrdersEntry entries.
Definition Messages.h:6874
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:6978
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6964
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7000
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::LongOrderUpdate
LongOrderUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:6890
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:6921
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::LongOrderUpdate
LongOrderUpdate(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:6880
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::bookState
bool bookState(BookState::Enum &value) const noexcept
Provides access to bookState field.
Definition Messages.h:2601
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::tradingSide
bool tradingSide(TradingSide::Enum &value) const noexcept
Provides access to tradingSide field.
Definition Messages.h:2645
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:2749
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:2591
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::priceLimits
bool priceLimits(PriceLimits::Enum &value) const noexcept
Provides access to priceLimits field.
Definition Messages.h:2655
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::phaseQualifier
PhaseQualifier phaseQualifier() const noexcept
Provides access to phaseQualifier field.
Definition Messages.h:2623
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::session
Session::Enum session() const noexcept
Provides access to session field.
Definition Messages.h:2689
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::scheduledEventTime
bool scheduledEventTime(Uint64 &value) const noexcept
Provides access to scheduledEventTime field.
Definition Messages.h:2711
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:2581
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:2554
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::quoteSpreadMultiplier
bool quoteSpreadMultiplier(QuoteSpreadMultiplier::Enum &value) const noexcept
Provides access to quoteSpreadMultiplier field.
Definition Messages.h:2666
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:2735
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::orderEntryQualifier
bool orderEntryQualifier(OrderEntryQualifier::Enum &value) const noexcept
Provides access to orderEntryQualifier field.
Definition Messages.h:2678
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::scheduledEvent
bool scheduledEvent(ScheduledEvent::Enum &value) const noexcept
Provides access to scheduledEvent field.
Definition Messages.h:2700
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::instrumentState
bool instrumentState(InstrumentState::Enum &value) const noexcept
Provides access to instrumentState field.
Definition Messages.h:2722
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::MarketStatesEntry
MarketStatesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:2558
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::changeType
MarketDataChangeType::Enum changeType() const noexcept
Provides access to changeType field.
Definition Messages.h:2571
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::tradingPeriod
bool tradingPeriod(TradingPeriod::Enum &value) const noexcept
Provides access to tradingPeriod field.
Definition Messages.h:2634
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::statusReason
bool statusReason(StatusReason::Enum &value) const noexcept
Provides access to statusReason field.
Definition Messages.h:2612
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatusChange
MarketStatusChange(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:2778
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:2842
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:2799
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:2809
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStates
SbeGroup< MarketStatesEntry, GroupSizeEncoding, MessageSize > MarketStates
Repeating group containing MarketStatesEntry entries.
Definition Messages.h:2772
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:2868
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:2854
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:2890
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatusChange
MarketStatusChange(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:2788
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:2819
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::quantity
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition Messages.h:712
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:738
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::UpdatesEntry
UpdatesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:659
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::numberOfOrders
bool numberOfOrders(Uint16 &value) const noexcept
Provides access to numberOfOrders field.
Definition Messages.h:692
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::updateType
MarketDataUpdateType::Enum updateType() const noexcept
Provides access to updateType field.
Definition Messages.h:672
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:682
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::price
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition Messages.h:702
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:655
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:751
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:724
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::MarketUpdate
MarketUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:777
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:839
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:788
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:818
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:798
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::Updates
SbeGroup< UpdatesEntry, GroupSizeEncoding, MessageSize > Updates
Repeating group containing UpdatesEntry entries.
Definition Messages.h:761
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::MarketUpdate
MarketUpdate()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:865
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:851
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:887
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::MarketUpdate
MarketUpdate(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:767
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:808
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:1087
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::previousPriority
bool previousPriority(Uint64 &value) const noexcept
Provides access to previousPriority field.
Definition Messages.h:1011
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderPx
bool orderPx(Int64 &value) const noexcept
Provides access to orderPx field.
Definition Messages.h:1031
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderQuantity
bool orderQuantity(Uint64 &value) const noexcept
Provides access to orderQuantity field.
Definition Messages.h:1051
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::OrdersEntry
OrdersEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:968
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderSide
bool orderSide(OrderSide::Enum &value) const noexcept
Provides access to orderSide field.
Definition Messages.h:1041
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::pegOffset
bool pegOffset(Int8 &value) const noexcept
Provides access to pegOffset field.
Definition Messages.h:1061
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:980
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:964
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:1100
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1073
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderType
bool orderType(OrderType::Enum &value) const noexcept
Provides access to orderType field.
Definition Messages.h:1021
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::actionType
MarketDataActionType::Enum actionType() const noexcept
Provides access to actionType field.
Definition Messages.h:991
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderPriority
bool orderPriority(Uint64 &value) const noexcept
Provides access to orderPriority field.
Definition Messages.h:1001
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrderUpdate
OrderUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:1126
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:1188
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:1137
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:1167
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:1147
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrderUpdate
OrderUpdate(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:1116
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::Orders
SbeGroup< OrdersEntry, GroupSizeEncoding, MessageSize > Orders
Repeating group containing OrdersEntry entries.
Definition Messages.h:1110
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:1214
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:1200
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:1236
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:1157
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrderUpdate
OrderUpdate()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightRepEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:6307
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightRepEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:6265
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightRepEntry::OutrightRepEntry
OutrightRepEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:6269
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightRepEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:6293
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6579
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::lotMultiplier
bool lotMultiplier(Uint64 &value) const noexcept
Provides access to lotMultiplier field.
Definition Messages.h:6546
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:6357
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::derivativesInstrumentType
bool derivativesInstrumentType(DerivativesInstrumentType::Enum &value) const noexcept
Provides access to derivativesInstrumentType field.
Definition Messages.h:6492
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:6367
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::iSINCode
StrRef iSINCode() const noexcept
Provides access to iSINCode field.
Definition Messages.h:6407
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::maturityDate
StrRef maturityDate() const noexcept
Provides access to maturityDate field.
Definition Messages.h:6429
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::contractSymbolIndex
bool contractSymbolIndex(Uint32 &value) const noexcept
Provides access to contractSymbolIndex field.
Definition Messages.h:6387
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::derivativesInstrumentTradingCode
bool derivativesInstrumentTradingCode(StrRef &value) const noexcept
Provides access to derivativesInstrumentTradingCode field.
Definition Messages.h:6480
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::lastTradingDate
bool lastTradingDate(Uint16 &value) const noexcept
Provides access to lastTradingDate field.
Definition Messages.h:6460
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::daysToExpiry
bool daysToExpiry(Uint16 &value) const noexcept
Provides access to daysToExpiry field.
Definition Messages.h:6470
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::underlyingSymbolIndex
bool underlyingSymbolIndex(Uint32 &value) const noexcept
Provides access to underlyingSymbolIndex field.
Definition Messages.h:6526
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::underlyingDerivativesInstrumentTradingCode
bool underlyingDerivativesInstrumentTradingCode(StrRef &value) const noexcept
Provides access to underlyingDerivativesInstrumentTradingCode field.
Definition Messages.h:6515
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::cFI
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition Messages.h:6418
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::lotSize
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition Messages.h:6440
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::instrumentEventDate
bool instrumentEventDate(Uint16 &value) const noexcept
Provides access to instrumentEventDate field.
Definition Messages.h:6397
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::tradingUnit
bool tradingUnit(Uint64 &value) const noexcept
Provides access to tradingUnit field.
Definition Messages.h:6536
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:6377
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::expiryCycleType
bool expiryCycleType(ExpiryCycleType::Enum &value) const noexcept
Provides access to expiryCycleType field.
Definition Messages.h:6504
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::expirationDate
bool expirationDate(Uint16 &value) const noexcept
Provides access to expirationDate field.
Definition Messages.h:6557
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:6606
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6592
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:6628
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightRep
SbeGroup< OutrightRepEntry, GroupSizeEncoding, MessageSize > OutrightRep
Repeating group containing OutrightRepEntry entries.
Definition Messages.h:6330
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightStandingData
OutrightStandingData(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:6336
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::strikePrice
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition Messages.h:6450
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightStandingData
OutrightStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:6346
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::quantity
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition Messages.h:1360
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:1420
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::imbalanceQty
bool imbalanceQty(Uint64 &value) const noexcept
Provides access to imbalanceQty field.
Definition Messages.h:1370
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:1340
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::price
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition Messages.h:1350
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:1313
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:1433
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1406
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::priceType
MarketDataPriceType::Enum priceType() const noexcept
Provides access to priceType field.
Definition Messages.h:1330
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::imbalanceQtySide
bool imbalanceQtySide(ImbalanceQuantitySide::Enum &value) const noexcept
Provides access to imbalanceQtySide field.
Definition Messages.h:1381
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::priceQualifier
bool priceQualifier(PriceQualifier::Enum &value) const noexcept
Provides access to priceQualifier field.
Definition Messages.h:1393
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::PricesEntry
PricesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:1317
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:1521
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:1470
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:1500
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:1480
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::Prices
SbeGroup< PricesEntry, GroupSizeEncoding, MessageSize > Prices
Repeating group containing PricesEntry entries.
Definition Messages.h:1443
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:1547
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PriceUpdate
PriceUpdate()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:1533
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:1569
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PriceUpdate
PriceUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:1459
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PriceUpdate
PriceUpdate(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:1449
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:1490
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::RealTimeIndex
RealTimeIndex(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4320
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4444
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:4331
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:4361
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:4341
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::pctgOfCapitalization
bool pctgOfCapitalization(Uint64 &value) const noexcept
Provides access to pctgOfCapitalization field.
Definition Messages.h:4391
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::indexPriceCode
IndexPriceCode::Enum indexPriceCode() const noexcept
Provides access to indexPriceCode field.
Definition Messages.h:4431
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::indexLevelType
IndexLevelType::Enum indexLevelType() const noexcept
Provides access to indexLevelType field.
Definition Messages.h:4421
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::prctVarfromPrevClose
bool prctVarfromPrevClose(Int64 &value) const noexcept
Provides access to prctVarfromPrevClose field.
Definition Messages.h:4401
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:4371
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::RealTimeIndex
RealTimeIndex(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:4310
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:4470
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4456
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::numTradedInstruments
bool numTradedInstruments(Uint16 &value) const noexcept
Provides access to numTradedInstruments field.
Definition Messages.h:4411
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4492
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:4351
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::indexLevel
bool indexLevel(Int64 &value) const noexcept
Provides access to indexLevel field.
Definition Messages.h:4381
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::RealTimeIndex
RealTimeIndex()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::patternId
bool patternId(Uint16 &value) const noexcept
Provides access to patternID field.
Definition Messages.h:3339
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:3417
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::marketModel
bool marketModel(MarketModel::Enum &value) const noexcept
Provides access to marketModel field.
Definition Messages.h:3359
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::lotSize
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition Messages.h:3369
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:3313
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::instUnitExp
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition Messages.h:3380
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::anonymous
bool anonymous(Anonymous::Enum &value) const noexcept
Provides access to anonymous field.
Definition Messages.h:3391
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:3430
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:3403
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::EmmPatternRepEntry
EmmPatternRepEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:3317
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:3329
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::tickSizeIndexId
bool tickSizeIndexId(Uint16 &value) const noexcept
Provides access to tickSizeIndexID field.
Definition Messages.h:3349
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::underlyingMIC
bool underlyingMIC(StrRef &value) const noexcept
Provides access to underlyingMIC field.
Definition Messages.h:3834
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::thresholdLISPostTrade60mn
bool thresholdLISPostTrade60mn(Uint64 &value) const noexcept
Provides access to thresholdLISPostTrade60mn field.
Definition Messages.h:4084
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::taxCode
bool taxCode(TaxCode::Enum &value) const noexcept
Provides access to taxCode field.
Definition Messages.h:3966
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4192
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::priceDecimals
bool priceDecimals(UnsignedChar &value) const noexcept
Provides access to priceDecimals field.
Definition Messages.h:3572
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:3467
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::guaranteeIndicator
bool guaranteeIndicator(GuaranteeIndicator::Enum &value) const noexcept
Provides access to guaranteeIndicator field.
Definition Messages.h:3716
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maxOrderAmountCall
bool maxOrderAmountCall(Uint64 &value) const noexcept
Provides access to maxOrderAmountCall field.
Definition Messages.h:4126
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::longMnemonic
bool longMnemonic(StrRef &value) const noexcept
Provides access to longMnemonic field.
Definition Messages.h:4114
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::strikeCurrencyIndicator
bool strikeCurrencyIndicator(StrikeCurrencyIndicator::Enum &value) const noexcept
Provides access to strikeCurrencyIndicator field.
Definition Messages.h:3890
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:3477
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::issuingCountry
bool issuingCountry(StrRef &value) const noexcept
Provides access to issuingCountry field.
Definition Messages.h:3738
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::iSINCode
StrRef iSINCode() const noexcept
Provides access to iSINCode field.
Definition Messages.h:3561
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::mnemonic
bool mnemonic(StrRef &value) const noexcept
Provides access to mnemonic field.
Definition Messages.h:3823
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::StandingData
StandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:3456
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::iCBCode
bool iCBCode(StrRef &value) const noexcept
Provides access to iCBCode field.
Definition Messages.h:4073
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRep
SbeGroup< EmmPatternRepEntry, GroupSizeEncoding, MessageSize > EmmPatternRep
Repeating group containing EmmPatternRepEntry entries.
Definition Messages.h:3440
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::mIC
StrRef mIC() const noexcept
Provides access to mIC field.
Definition Messages.h:3790
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::ratioDecimals
bool ratioDecimals(UnsignedChar &value) const noexcept
Provides access to ratioDecimals field.
Definition Messages.h:3602
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::iCB
bool iCB(StrRef &value) const noexcept
Provides access to iCB field.
Definition Messages.h:3727
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::mainDepositary
bool mainDepositary(StrRef &value) const noexcept
Provides access to mainDepositary field.
Definition Messages.h:3694
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::cFI
StrRef cFI() const noexcept
Provides access to cFI field.
Definition Messages.h:3612
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::marketOfReferenceMIC
bool marketOfReferenceMIC(StrRef &value) const noexcept
Provides access to marketOfReferenceMIC field.
Definition Messages.h:4062
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::nominalCurrency
bool nominalCurrency(StrRef &value) const noexcept
Provides access to nominalCurrency field.
Definition Messages.h:4021
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maximumDecimalsInQuantity
bool maximumDecimalsInQuantity(UnsignedChar &value) const noexcept
Provides access to maximumDecimalsInQuantity field.
Definition Messages.h:3780
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::tradingCurrency
bool tradingCurrency(StrRef &value) const noexcept
Provides access to tradingCurrency field.
Definition Messages.h:3856
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::issuePriceDecimals
bool issuePriceDecimals(UnsignedChar &value) const noexcept
Provides access to issuePriceDecimals field.
Definition Messages.h:4032
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maturityDate
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition Messages.h:3769
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::darkMinQuantity
bool darkMinQuantity(Uint32 &value) const noexcept
Provides access to darkMinQuantity field.
Definition Messages.h:3663
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::depositaryList
bool depositaryList(StrRef &value) const noexcept
Provides access to depositaryList field.
Definition Messages.h:3683
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::amountDecimals
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition Messages.h:3592
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::countryOfExchange
bool countryOfExchange(StrRef &value) const noexcept
Provides access to countryOfExchange field.
Definition Messages.h:3812
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::underlyingISINCode
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition Messages.h:3845
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::lotSize
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition Messages.h:3759
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::issuePrice
bool issuePrice(Int64 &value) const noexcept
Provides access to issuePrice field.
Definition Messages.h:4011
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::thresholdLISPostTrade120mn
bool thresholdLISPostTrade120mn(Uint64 &value) const noexcept
Provides access to thresholdLISPostTrade120mn field.
Definition Messages.h:4094
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::darkLISThreshold
bool darkLISThreshold(Uint64 &value) const noexcept
Provides access to darkLISThreshold field.
Definition Messages.h:3653
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instrumentEventDate
bool instrumentEventDate(Uint16 &value) const noexcept
Provides access to instrumentEventDate field.
Definition Messages.h:3623
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:3487
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::quantityNotation
bool quantityNotation(StrRef &value) const noexcept
Provides access to quantityNotation field.
Definition Messages.h:3921
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::dateOfLastTrade
bool dateOfLastTrade(Uint16 &value) const noexcept
Provides access to dateOfLastTrade field.
Definition Messages.h:3673
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::typeOfCorporateEvent
bool typeOfCorporateEvent(StrRef &value) const noexcept
Provides access to typeOfCorporateEvent field.
Definition Messages.h:3976
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instUnitExp
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition Messages.h:3933
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::poolFactor
bool poolFactor(Uint32 &value) const noexcept
Provides access to poolFactor field.
Definition Messages.h:4170
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::optiqSegment
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition Messages.h:3497
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:4221
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::settlementDelay
bool settlementDelay(StrRef &value) const noexcept
Provides access to settlementDelay field.
Definition Messages.h:3944
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::quantityDecimals
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition Messages.h:3582
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4207
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::typeOfMarketAdmission
bool typeOfMarketAdmission(TypeOfMarketAdmission::Enum &value) const noexcept
Provides access to typeOfMarketAdmission field.
Definition Messages.h:3988
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::thresholdLISPostTradeEOD
bool thresholdLISPostTradeEOD(Uint64 &value) const noexcept
Provides access to thresholdLISPostTradeEOD field.
Definition Messages.h:4104
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::strikeCurrency
bool strikeCurrency(StrRef &value) const noexcept
Provides access to strikeCurrency field.
Definition Messages.h:3955
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4243
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::liquidInstrumentIndicator
bool liquidInstrumentIndicator(UnsignedChar &value) const noexcept
Provides access to liquidInstrumentIndicator field.
Definition Messages.h:4052
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maxOrderAmountContinuous
bool maxOrderAmountContinuous(Uint64 &value) const noexcept
Provides access to maxOrderAmountContinuous field.
Definition Messages.h:4137
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maxOrderQuantityCall
bool maxOrderQuantityCall(Uint64 &value) const noexcept
Provides access to maxOrderQuantityCall field.
Definition Messages.h:4148
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::strikePriceDecimals
bool strikePriceDecimals(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimals field.
Definition Messages.h:4042
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::repoIndicator
bool repoIndicator(RepoIndicator::Enum &value) const noexcept
Provides access to repoIndicator field.
Definition Messages.h:4000
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::tradingCurrencyIndicator
bool tradingCurrencyIndicator(TradingCurrencyIndicator::Enum &value) const noexcept
Provides access to tradingCurrencyIndicator field.
Definition Messages.h:3878
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::parValue
bool parValue(Uint64 &value) const noexcept
Provides access to parValue field.
Definition Messages.h:3911
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::StandingData
StandingData(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:3446
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maxOrderQuantityContinuous
bool maxOrderQuantityContinuous(Uint64 &value) const noexcept
Provides access to maxOrderQuantityContinuous field.
Definition Messages.h:4159
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::StandingData
StandingData()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::darkEligibility
bool darkEligibility(UnsignedChar &value) const noexcept
Provides access to darkEligibility field.
Definition Messages.h:3643
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::lastAdjustedClosingPrice
bool lastAdjustedClosingPrice(Int64 &value) const noexcept
Provides access to lastAdjustedClosingPrice field.
Definition Messages.h:3749
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::partitionId
bool partitionId(Uint16 &value) const noexcept
Provides access to partitionID field.
Definition Messages.h:3507
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::strikePrice
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition Messages.h:3633
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::numberInstrumentCirculating
bool numberInstrumentCirculating(Uint64 &value) const noexcept
Provides access to numberInstrumentCirculating field.
Definition Messages.h:3901
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::currencyCoefficient
bool currencyCoefficient(Uint32 &value) const noexcept
Provides access to currencyCoefficient field.
Definition Messages.h:3867
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instrumentName
StrRef instrumentName() const noexcept
Provides access to instrumentName field.
Definition Messages.h:3528
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::firstSettlementDate
bool firstSettlementDate(Uint16 &value) const noexcept
Provides access to firstSettlementDate field.
Definition Messages.h:3705
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::fullInstrumentName
bool fullInstrumentName(StrRef &value) const noexcept
Provides access to fullInstrumentName field.
Definition Messages.h:3517
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instrumentTradingCode
bool instrumentTradingCode(StrRef &value) const noexcept
Provides access to instrumentTradingCode field.
Definition Messages.h:3539
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instrumentGroupCode
StrRef instrumentGroupCode() const noexcept
Provides access to instrumentGroupCode field.
Definition Messages.h:3550
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::mICList
bool mICList(StrRef &value) const noexcept
Provides access to mICList field.
Definition Messages.h:3801
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:92
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:69
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::StartOfDay
StartOfDay()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::StartOfDay
StartOfDay(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:48
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:118
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:104
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:140
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::sessionTradingDay
bool sessionTradingDay(Uint16 &value) const noexcept
Provides access to sessionTradingDay field.
Definition Messages.h:79
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfDay::StartOfDay
StartOfDay(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:58
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9968
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::lastMDSeqNum
bool lastMDSeqNum(Uint64 &value) const noexcept
Provides access to lastMDSeqNum field.
Definition Messages.h:9945
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::StartOfSnapshot
StartOfSnapshot(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:9924
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::StartOfSnapshot
StartOfSnapshot(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:9934
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::snapshotTime
bool snapshotTime(Uint64 &value) const noexcept
Provides access to snapshotTime field.
Definition Messages.h:9955
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:9994
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9980
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:10016
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:4601
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::statsUpdateValue
bool statsUpdateValue(Int64 &value) const noexcept
Provides access to statsUpdateValue field.
Definition Messages.h:4575
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:4549
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:4614
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:4587
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::NewStatsEntry
NewStatsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:4553
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::statsUpdateType
StatsUpdateType::Enum statsUpdateType() const noexcept
Provides access to statsUpdateType field.
Definition Messages.h:4565
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4692
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:4651
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:4661
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::Statistics
Statistics()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::Statistics
Statistics(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4640
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:4671
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:4718
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4704
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStats
SbeGroup< NewStatsEntry, GroupSizeEncoding, MessageSize > NewStats
Repeating group containing NewStatsEntry entries.
Definition Messages.h:4624
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4740
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::Statistics
Statistics(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:4630
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::legSymbolIndex
bool legSymbolIndex(Uint32 &value) const noexcept
Provides access to legSymbolIndex field.
Definition Messages.h:5132
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::legBuySell
LegBuyorSell::Enum legBuySell() const noexcept
Provides access to legBuySell field.
Definition Messages.h:5162
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::legRatio
bool legRatio(Uint32 &value) const noexcept
Provides access to legRatio field.
Definition Messages.h:5152
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::StrategyStandingDatarep1Entry
StrategyStandingDatarep1Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:5120
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::legPrice
bool legPrice(Int64 &value) const noexcept
Provides access to legPrice field.
Definition Messages.h:5142
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:5354
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:5238
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:5248
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::maturityDate
StrRef maturityDate() const noexcept
Provides access to maturityDate field.
Definition Messages.h:5299
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::contractSymbolIndex
bool contractSymbolIndex(Uint32 &value) const noexcept
Provides access to contractSymbolIndex field.
Definition Messages.h:5320
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::cFI
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition Messages.h:5330
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:5268
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:5380
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::strategyStandingDatarep1
StrategyStandingDatarep1 strategyStandingDatarep1() const noexcept
Definition Messages.h:5341
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5366
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1
SbeGroup< StrategyStandingDatarep1Entry, GroupSizeEncoding, MessageSize > StrategyStandingDatarep1
Repeating group containing StrategyStandingDatarep1Entry entries.
Definition Messages.h:5211
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:5402
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::derivativesInstrumentTradingCode
StrRef derivativesInstrumentTradingCode() const noexcept
Provides access to derivativesInstrumentTradingCode field.
Definition Messages.h:5278
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingData
StrategyStandingData(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:5217
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:5258
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::exchangeCode
ExchangeCode::Enum exchangeCode() const noexcept
Provides access to exchangeCode field.
Definition Messages.h:5289
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::strategyCode
StrategyCode::Enum strategyCode() const noexcept
Provides access to strategyCode field.
Definition Messages.h:5310
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingData
StrategyStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:5227
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:550
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:486
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::retransmissionEndTime
bool retransmissionEndTime(Uint64 &value) const noexcept
Provides access to retransmissionEndTime field.
Definition Messages.h:527
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:507
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:537
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::TechnicalNotification
TechnicalNotification(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:465
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::retransmissionStartTime
bool retransmissionStartTime(Uint64 &value) const noexcept
Provides access to retransmissionStartTime field.
Definition Messages.h:517
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:576
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:562
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:598
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::TechnicalNotification
TechnicalNotification(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:475
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::technicalNotificationType
TechnicalNotificationType::Enum technicalNotificationType() const noexcept
Provides access to technicalNotificationType field.
Definition Messages.h:497
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:3075
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::phaseTime
bool phaseTime(Uint64 &value) const noexcept
Provides access to phaseTime field.
Definition Messages.h:2985
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::tradingPeriod
TradingPeriod::Enum tradingPeriod() const noexcept
Provides access to tradingPeriod field.
Definition Messages.h:3015
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::phaseQualifier
PhaseQualifier phaseQualifier() const noexcept
Provides access to phaseQualifier field.
Definition Messages.h:3005
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::session
Session::Enum session() const noexcept
Provides access to session field.
Definition Messages.h:3037
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:2969
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::phaseId
PhaseId::Enum phaseId() const noexcept
Provides access to phaseId field.
Definition Messages.h:2995
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:3088
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:3061
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::orderEntryQualifier
bool orderEntryQualifier(OrderEntryQualifier::Enum &value) const noexcept
Provides access to orderEntryQualifier field.
Definition Messages.h:3026
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::scheduledEvent
bool scheduledEvent(ScheduledEvent::Enum &value) const noexcept
Provides access to scheduledEvent field.
Definition Messages.h:3048
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::TimetablesEntry
TimetablesEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:2973
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::patternId
bool patternId(Uint16 &value) const noexcept
Provides access to patternID field.
Definition Messages.h:3155
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:3188
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::eMM
bool eMM(Emm::Enum &value) const noexcept
Provides access to eMM field.
Definition Messages.h:3145
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:3125
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:3135
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:3165
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:3214
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:3200
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:3236
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::Timetable
Timetable()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::Timetable
Timetable(const void *data, EncodedLength length)
Creates an instance over the given memory block.
Definition Messages.h:3104
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::Timetables
SbeGroup< TimetablesEntry, GroupSizeEncoding, MessageSize > Timetables
Repeating group containing TimetablesEntry entries.
Definition Messages.h:3098
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::Timetable
Timetable(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:3114