OnixS C++ Euronext Optiq MDG Handler 1.3.3
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() ONIXS_EURONEXT_OPTIQMDG_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 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
71 {
72 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_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 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
81 {
82 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
83
84 return ordinary(value, offset, NullUint16());
85 }
86
88 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
89 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
90 static
91 BlockLength
100
102 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
103 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
104 static BlockLength blockLength(SchemaVersion version)
105 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
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 ONIXS_EURONEXT_OPTIQMDG_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 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
130 static const Char* className()
131 {
132 return "StartOfDay";
133 }
134
136 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
137 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
138 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
139 static StrRef fixType()
140 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
141 {
142 return constructStrRef("StartOfDay");
143 }
144
146 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
147 std::string toString() const;
148
149private:
150 void checkLength(
151 EncodedLength length, SchemaVersion version) const
152 {
153 const EncodedLength minimalRequiredLength =
154 minimalBlockLength(version) +
155 MessageHeader::Size +
156 getMinimalVariableFieldsSize(version);
157
158 checkBinaryLength(
159 *this, length, minimalRequiredLength);
160 }
161
162 void checkCompatibility() const
163 {
164 assert(TemplateId == templateId());
165
166 checkSchema<Schema>(schemaId(), version());
167 checkLength(bufferSize(), version());
168 }
169};
170
172ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
173EndOfDay
174: SbeMessage
175{
177 typedef SchemaTraits Schema;
178
180 enum { TemplateId = 1102 };
181
183 EndOfDay() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
184
186 EndOfDay(
187 const void* data,
188 EncodedLength length)
189 : SbeMessage(data, length)
190 {
191 checkCompatibility();
192 }
193
195 explicit
196 EndOfDay(
197 const SbeMessage& message)
198 : SbeMessage(message)
199 {
200 assert(message.valid());
201
202 checkCompatibility();
203 }
204
206 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
207 bool seqNum(Uint64& value) const
208 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
209 {
210 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
211
212 return ordinary(value, offset, NullUint64());
213 }
214
216 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
217 bool sessionTradingDay(Uint16& value) const
218 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
219 {
220 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
221
222 return ordinary(value, offset, NullUint16());
223 }
224
226 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
227 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
228 static
229 BlockLength
230 minimalBlockLength(
231 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
232 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
233 {
234 return
235 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
236 10;
237 }
238
240 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
241 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
242 static BlockLength blockLength(SchemaVersion version)
243 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
244 {
245 return
246 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
247 minimalBlockLength(version);
248 }
249
251 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
252 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
253 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
254 static
255 MessageSize
256 getMinimalVariableFieldsSize(
257 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
258 {
259 return
260 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
261 0;
262 }
263
265 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
266 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
267 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
268 static const Char* className()
269 {
270 return "EndOfDay";
271 }
272
274 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
275 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
276 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
277 static StrRef fixType()
278 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
279 {
280 return constructStrRef("EndOfDay");
281 }
282
284 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
285 std::string toString() const;
286
287private:
288 void checkLength(
289 EncodedLength length, SchemaVersion version) const
290 {
291 const EncodedLength minimalRequiredLength =
292 minimalBlockLength(version) +
293 MessageHeader::Size +
294 getMinimalVariableFieldsSize(version);
295
296 checkBinaryLength(
297 *this, length, minimalRequiredLength);
298 }
299
300 void checkCompatibility() const
301 {
302 assert(TemplateId == templateId());
303
304 checkSchema<Schema>(schemaId(), version());
305 checkLength(bufferSize(), version());
306 }
307};
308
310ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
311HealthStatus
312: SbeMessage
313{
315 typedef SchemaTraits Schema;
316
318 enum { TemplateId = 1103 };
319
321 HealthStatus() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
322
324 HealthStatus(
325 const void* data,
326 EncodedLength length)
327 : SbeMessage(data, length)
328 {
329 checkCompatibility();
330 }
331
333 explicit
334 HealthStatus(
335 const SbeMessage& message)
336 : SbeMessage(message)
337 {
338 assert(message.valid());
339
340 checkCompatibility();
341 }
342
344 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
345 bool seqNum(Uint64& value) const
346 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
347 {
348 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
349
350 return ordinary(value, offset, NullUint64());
351 }
352
354 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
355 bool eventTime(Uint64& value) const
356 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
357 {
358 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
359
360 return ordinary(value, offset, NullUint64());
361 }
362
364 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
365 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
366 static
367 BlockLength
368 minimalBlockLength(
369 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
370 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
371 {
372 return
373 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
374 16;
375 }
376
378 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
379 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
380 static BlockLength blockLength(SchemaVersion version)
381 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
382 {
383 return
384 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
385 minimalBlockLength(version);
386 }
387
389 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
390 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
391 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
392 static
393 MessageSize
394 getMinimalVariableFieldsSize(
395 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
396 {
397 return
398 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
399 0;
400 }
401
403 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
404 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
405 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
406 static const Char* className()
407 {
408 return "HealthStatus";
409 }
410
412 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
413 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
414 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
415 static StrRef fixType()
416 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
417 {
418 return constructStrRef("HealthStatus");
419 }
420
422 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
423 std::string toString() const;
424
425private:
426 void checkLength(
427 EncodedLength length, SchemaVersion version) const
428 {
429 const EncodedLength minimalRequiredLength =
430 minimalBlockLength(version) +
431 MessageHeader::Size +
432 getMinimalVariableFieldsSize(version);
433
434 checkBinaryLength(
435 *this, length, minimalRequiredLength);
436 }
437
438 void checkCompatibility() const
439 {
440 assert(TemplateId == templateId());
441
442 checkSchema<Schema>(schemaId(), version());
443 checkLength(bufferSize(), version());
444 }
445};
446
448ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
449TechnicalNotification
450: SbeMessage
451{
453 typedef SchemaTraits Schema;
454
456 enum { TemplateId = 1106 };
457
459 TechnicalNotification() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
460
462 TechnicalNotification(
463 const void* data,
464 EncodedLength length)
465 : SbeMessage(data, length)
466 {
467 checkCompatibility();
468 }
469
471 explicit
472 TechnicalNotification(
473 const SbeMessage& message)
474 : SbeMessage(message)
475 {
476 assert(message.valid());
477
478 checkCompatibility();
479 }
480
482 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
483 bool seqNum(Uint64& value) const
484 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
485 {
486 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
487
488 return ordinary(value, offset, NullUint64());
489 }
490
492 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
493 TechnicalNotificationType::Enum
501
503 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
511
513 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
514 bool retransmissionStartTime(Uint64& value) const
515 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
516 {
517 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
518
519 return ordinary(value, offset, NullUint64());
520 }
521
523 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
524 bool retransmissionEndTime(Uint64& value) const
525 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
526 {
527 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 18;
528
529 return ordinary(value, offset, NullUint64());
530 }
531
533 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
534 bool symbolIndex(Uint32& value) const
535 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
536 {
537 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 26;
538
539 return ordinary(value, offset, NullUint32());
540 }
541
543 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
544 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
545 static
546 BlockLength
547 minimalBlockLength(
548 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
549 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
550 {
551 return
552 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
553 30;
554 }
555
557 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
558 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
559 static BlockLength blockLength(SchemaVersion version)
560 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
561 {
562 return
563 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
564 minimalBlockLength(version);
565 }
566
568 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
569 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
570 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
571 static
572 MessageSize
573 getMinimalVariableFieldsSize(
574 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
575 {
576 return
577 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
578 0;
579 }
580
582 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
583 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
584 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
585 static const Char* className()
586 {
587 return "TechnicalNotification";
588 }
589
591 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
592 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
593 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
594 static StrRef fixType()
595 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
596 {
597 return constructStrRef("TechnicalNotification");
598 }
599
601 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
602 std::string toString() const;
603
604private:
605 void checkLength(
606 EncodedLength length, SchemaVersion version) const
607 {
608 const EncodedLength minimalRequiredLength =
609 minimalBlockLength(version) +
610 MessageHeader::Size +
611 getMinimalVariableFieldsSize(version);
612
613 checkBinaryLength(
614 *this, length, minimalRequiredLength);
615 }
616
617 void checkCompatibility() const
618 {
619 assert(TemplateId == templateId());
620
621 checkSchema<Schema>(schemaId(), version());
622 checkLength(bufferSize(), version());
623 }
624};
625
627ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
628MarketUpdate
629: SbeMessage
630{
632 typedef SchemaTraits Schema;
633
635 enum { TemplateId = 1001 };
636
639 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
640 UpdatesEntry : SbeGroupEntry
641 <
642 GroupSizeEncoding::BlockLength
643 >
644 {
646 typedef
647 SbeGroupEntry
648 <
649 GroupSizeEncoding::BlockLength
650 >
651 Base;
652
655 UpdatesEntry(
656 const void* data,
657 EncodedLength length,
658 SchemaVersion version)
659 : Base(data, numericCast<Base::BlockLength>(length), version)
660 {
661 assert(version >= Schema::MinimalVersion);
662 assert(length >= minimalBlockLength(version));
663 }
664
666 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
667 MarketDataUpdateType::Enum
675
677 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
678 bool symbolIndex(Uint32& value) const
679 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
680 {
681 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 1;
682
683 return ordinary(value, offset, NullUint32());
684 }
685
687 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
688 bool numberOfOrders(Uint16& value) const
689 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
690 {
691 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 5;
692
693 return ordinary(value, offset, NullUint16());
694 }
695
697 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
698 bool price(Int64& value) const
699 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
700 {
701 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 7;
702
703 return ordinary(value, offset, NullInt64());
704 }
705
707 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
708 bool quantity(Uint64& value) const
709 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
710 {
711 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 15;
712
713 return ordinary(value, offset, NullUint64());
714 }
715
718 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
719 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
720 static BlockLength blockLength(SchemaVersion version)
721 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
722 {
723 return
724 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
725 minimalBlockLength(version);
726 }
727
730 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
731 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
732 static
733 BlockLength
734 minimalBlockLength(
735 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
736 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
737 {
738 return
739 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
740 23;
741 }
742
744 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
745 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
746 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
747 static const Char* className()
748 {
749 return "MarketUpdate.UpdatesEntry";
750 }
751 };
752
754 typedef
755 SbeGroup<UpdatesEntry, GroupSizeEncoding, MessageSize>
756 Updates;
757
759 MarketUpdate() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
760
762 MarketUpdate(
763 const void* data,
764 EncodedLength length)
765 : SbeMessage(data, length)
766 {
767 checkCompatibility();
768 }
769
771 explicit
772 MarketUpdate(
773 const SbeMessage& message)
774 : SbeMessage(message)
775 {
776 assert(message.valid());
777
778 checkCompatibility();
779 }
780
782 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
783 bool seqNum(Uint64& value) const
784 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
785 {
786 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
787
788 return ordinary(value, offset, NullUint64());
789 }
790
792 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
800
802 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
810
812 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
813 bool eventTime(Uint64& value) const
814 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
815 {
816 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
817
818 return ordinary(value, offset, NullUint64());
819 }
820
822 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
823 Updates updates() const
824 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
825 {
826 return getGroup<Updates>(UpdatesAccess(), *this);
827 }
828
830 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
831 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
832 static
833 BlockLength
834 minimalBlockLength(
835 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
836 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
837 {
838 return
839 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
840 18;
841 }
842
844 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
845 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
846 static BlockLength blockLength(SchemaVersion version)
847 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
848 {
849 return
850 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
851 minimalBlockLength(version);
852 }
853
855 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
856 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
857 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
858 static
859 MessageSize
860 getMinimalVariableFieldsSize(
861 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
862 {
863 return
864 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
865 static_cast<MessageSize>(Updates::EmptySize);
866 }
867
869 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
870 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
871 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
872 static const Char* className()
873 {
874 return "MarketUpdate";
875 }
876
878 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
879 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
880 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
881 static StrRef fixType()
882 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
883 {
884 return constructStrRef("MarketUpdate");
885 }
886
888 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
889 std::string toString() const;
890
891private:
892 void checkLength(
893 EncodedLength length, SchemaVersion version) const
894 {
895 const EncodedLength minimalRequiredLength =
896 minimalBlockLength(version) +
897 MessageHeader::Size +
898 getMinimalVariableFieldsSize(version);
899
900 checkBinaryLength(
901 *this, length, minimalRequiredLength);
902 }
903
905 void checkVarLenFields() const
906 {
907 groups().
908 checkTail<Updates>();
909 }
910
911 void checkCompatibility() const
912 {
913 assert(TemplateId == templateId());
914
915 checkSchema<Schema>(schemaId(), version());
916 checkLength(bufferSize(), version());
917 checkVarLenFields();
918 }
919
921 struct UpdatesAccess
922 {
923 Updates operator()(const MarketUpdate& obj) const
924 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
925 {
926 return obj.
927 groups().
928 head<Updates>();
929 }
930 };
931};
932
934ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
935OrderUpdate
936: SbeMessage
937{
939 typedef SchemaTraits Schema;
940
942 enum { TemplateId = 1002 };
943
946 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
947 OrdersEntry : SbeGroupEntry
948 <
949 GroupSizeEncoding::BlockLength
950 >
951 {
953 typedef
954 SbeGroupEntry
955 <
956 GroupSizeEncoding::BlockLength
957 >
958 Base;
959
962 OrdersEntry(
963 const void* data,
964 EncodedLength length,
965 SchemaVersion version)
966 : Base(data, numericCast<Base::BlockLength>(length), version)
967 {
968 assert(version >= Schema::MinimalVersion);
969 assert(length >= minimalBlockLength(version));
970 }
971
973 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
974 bool symbolIndex(Uint32& value) const
975 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
976 {
977 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
978
979 return ordinary(value, offset, NullUint32());
980 }
981
983 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
984 MarketDataActionType::Enum
992
994 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
995 bool orderPriority(Uint64& value) const
996 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
997 {
998 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 5;
999
1000 return ordinary(value, offset, NullUint64());
1001 }
1002
1004 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1005 bool previousPriority(Uint64& value) const
1006 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1007 {
1008 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 13;
1009
1010 return ordinary(value, offset, NullUint64());
1011 }
1012
1014 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1015 bool orderType(OrderType::Enum& value) const
1016 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1017 {
1018 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 21;
1019
1020 return enumeration<OrderType>(value, offset, NullUInt8());
1021 }
1022
1024 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1025 bool orderPx(Int64& value) const
1026 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1027 {
1028 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 22;
1029
1030 return ordinary(value, offset, NullInt64());
1031 }
1032
1034 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1035 bool orderSide(OrderSide::Enum& value) const
1036 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1037 {
1038 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 30;
1039
1040 return enumeration<OrderSide>(value, offset, NullUInt8());
1041 }
1042
1044 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1045 bool orderQuantity(Uint64& value) const
1046 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1047 {
1048 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 31;
1049
1050 return ordinary(value, offset, NullUint64());
1051 }
1052
1054 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1055 bool pegOffset(Int8& value) const
1056 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1057 {
1058 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 39;
1059
1060 return ordinary(value, offset, NullInt8());
1061 }
1062
1065 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1066 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1067 static BlockLength blockLength(SchemaVersion version)
1068 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1069 {
1070 return
1071 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1072 minimalBlockLength(version);
1073 }
1074
1077 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1078 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1079 static
1080 BlockLength
1081 minimalBlockLength(
1082 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1083 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1084 {
1085 return
1086 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1087 40;
1088 }
1089
1091 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1092 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1093 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1094 static const Char* className()
1095 {
1096 return "OrderUpdate.OrdersEntry";
1097 }
1098 };
1099
1101 typedef
1102 SbeGroup<OrdersEntry, GroupSizeEncoding, MessageSize>
1103 Orders;
1104
1106 OrderUpdate() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
1107
1109 OrderUpdate(
1110 const void* data,
1111 EncodedLength length)
1112 : SbeMessage(data, length)
1113 {
1114 checkCompatibility();
1115 }
1116
1118 explicit
1119 OrderUpdate(
1120 const SbeMessage& message)
1121 : SbeMessage(message)
1122 {
1123 assert(message.valid());
1124
1125 checkCompatibility();
1126 }
1127
1129 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1130 bool seqNum(Uint64& value) const
1131 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1132 {
1133 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
1134
1135 return ordinary(value, offset, NullUint64());
1136 }
1137
1139 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1140 bool rebroadcastIndicator(UnsignedChar& value) const
1141 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1142 {
1143 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
1144
1145 return ordinary(value, offset, NullUnsignedChar());
1146 }
1147
1149 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1157
1159 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1160 bool eventTime(Uint64& value) const
1161 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1162 {
1163 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
1164
1165 return ordinary(value, offset, NullUint64());
1166 }
1167
1169 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1170 Orders orders() const
1171 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1172 {
1173 return getGroup<Orders>(OrdersAccess(), *this);
1174 }
1175
1177 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1178 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1179 static
1180 BlockLength
1181 minimalBlockLength(
1182 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1183 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1184 {
1185 return
1186 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1187 18;
1188 }
1189
1191 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1192 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1193 static BlockLength blockLength(SchemaVersion version)
1194 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1195 {
1196 return
1197 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1198 minimalBlockLength(version);
1199 }
1200
1202 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1203 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1204 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1205 static
1206 MessageSize
1207 getMinimalVariableFieldsSize(
1208 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1209 {
1210 return
1211 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1212 static_cast<MessageSize>(Orders::EmptySize);
1213 }
1214
1216 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1217 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1218 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1219 static const Char* className()
1220 {
1221 return "OrderUpdate";
1222 }
1223
1225 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1226 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1227 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1228 static StrRef fixType()
1229 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1230 {
1231 return constructStrRef("OrderUpdate");
1232 }
1233
1235 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1236 std::string toString() const;
1237
1238private:
1239 void checkLength(
1240 EncodedLength length, SchemaVersion version) const
1241 {
1242 const EncodedLength minimalRequiredLength =
1243 minimalBlockLength(version) +
1244 MessageHeader::Size +
1245 getMinimalVariableFieldsSize(version);
1246
1247 checkBinaryLength(
1248 *this, length, minimalRequiredLength);
1249 }
1250
1252 void checkVarLenFields() const
1253 {
1254 groups().
1255 checkTail<Orders>();
1256 }
1257
1258 void checkCompatibility() const
1259 {
1260 assert(TemplateId == templateId());
1261
1262 checkSchema<Schema>(schemaId(), version());
1263 checkLength(bufferSize(), version());
1264 checkVarLenFields();
1265 }
1266
1268 struct OrdersAccess
1269 {
1270 Orders operator()(const OrderUpdate& obj) const
1271 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1272 {
1273 return obj.
1274 groups().
1275 head<Orders>();
1276 }
1277 };
1278};
1279
1281ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
1282PriceUpdate
1283: SbeMessage
1284{
1286 typedef SchemaTraits Schema;
1287
1289 enum { TemplateId = 1003 };
1290
1293 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
1294 PricesEntry : SbeGroupEntry
1295 <
1296 GroupSizeEncoding::BlockLength
1297 >
1298 {
1300 typedef
1301 SbeGroupEntry
1302 <
1303 GroupSizeEncoding::BlockLength
1304 >
1305 Base;
1306
1309 PricesEntry(
1310 const void* data,
1311 EncodedLength length,
1312 SchemaVersion version)
1313 : Base(data, numericCast<Base::BlockLength>(length), version)
1314 {
1315 assert(version >= Schema::MinimalVersion);
1316 assert(length >= minimalBlockLength(version));
1317 }
1318
1320 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1321 MarketDataPriceType::Enum
1329
1331 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1332 bool symbolIndex(Uint32& value) const
1333 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1334 {
1335 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 1;
1336
1337 return ordinary(value, offset, NullUint32());
1338 }
1339
1341 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1342 bool price(Int64& value) const
1343 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1344 {
1345 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 5;
1346
1347 return ordinary(value, offset, NullInt64());
1348 }
1349
1351 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1352 bool quantity(Uint64& value) const
1353 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1354 {
1355 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 13;
1356
1357 return ordinary(value, offset, NullUint64());
1358 }
1359
1361 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1362 bool imbalanceQty(Uint64& value) const
1363 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1364 {
1365 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 21;
1366
1367 return ordinary(value, offset, NullUint64());
1368 }
1369
1371 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1372 bool
1381
1383 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1384 bool
1393
1396 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1397 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1398 static BlockLength blockLength(SchemaVersion version)
1399 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1400 {
1401 return
1402 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1403 minimalBlockLength(version);
1404 }
1405
1408 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1409 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1410 static
1411 BlockLength
1412 minimalBlockLength(
1413 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1414 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1415 {
1416 return
1417 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1418 31;
1419 }
1420
1422 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1423 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1424 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1425 static const Char* className()
1426 {
1427 return "PriceUpdate.PricesEntry";
1428 }
1429 };
1430
1432 typedef
1433 SbeGroup<PricesEntry, GroupSizeEncoding, MessageSize>
1434 Prices;
1435
1437 PriceUpdate() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
1438
1440 PriceUpdate(
1441 const void* data,
1442 EncodedLength length)
1443 : SbeMessage(data, length)
1444 {
1445 checkCompatibility();
1446 }
1447
1449 explicit
1450 PriceUpdate(
1451 const SbeMessage& message)
1452 : SbeMessage(message)
1453 {
1454 assert(message.valid());
1455
1456 checkCompatibility();
1457 }
1458
1460 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1461 bool seqNum(Uint64& value) const
1462 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1463 {
1464 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
1465
1466 return ordinary(value, offset, NullUint64());
1467 }
1468
1470 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1471 bool rebroadcastIndicator(UnsignedChar& value) const
1472 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1473 {
1474 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
1475
1476 return ordinary(value, offset, NullUnsignedChar());
1477 }
1478
1480 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1488
1490 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1491 bool eventTime(Uint64& value) const
1492 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1493 {
1494 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
1495
1496 return ordinary(value, offset, NullUint64());
1497 }
1498
1500 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1501 Prices prices() const
1502 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1503 {
1504 return getGroup<Prices>(PricesAccess(), *this);
1505 }
1506
1508 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1509 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1510 static
1511 BlockLength
1512 minimalBlockLength(
1513 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1514 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1515 {
1516 return
1517 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1518 18;
1519 }
1520
1522 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1523 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1524 static BlockLength blockLength(SchemaVersion version)
1525 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1526 {
1527 return
1528 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1529 minimalBlockLength(version);
1530 }
1531
1533 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1534 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1535 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1536 static
1537 MessageSize
1538 getMinimalVariableFieldsSize(
1539 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1540 {
1541 return
1542 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1543 static_cast<MessageSize>(Prices::EmptySize);
1544 }
1545
1547 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1548 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1549 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1550 static const Char* className()
1551 {
1552 return "PriceUpdate";
1553 }
1554
1556 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1557 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1558 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1559 static StrRef fixType()
1560 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1561 {
1562 return constructStrRef("PriceUpdate");
1563 }
1564
1566 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1567 std::string toString() const;
1568
1569private:
1570 void checkLength(
1571 EncodedLength length, SchemaVersion version) const
1572 {
1573 const EncodedLength minimalRequiredLength =
1574 minimalBlockLength(version) +
1575 MessageHeader::Size +
1576 getMinimalVariableFieldsSize(version);
1577
1578 checkBinaryLength(
1579 *this, length, minimalRequiredLength);
1580 }
1581
1583 void checkVarLenFields() const
1584 {
1585 groups().
1586 checkTail<Prices>();
1587 }
1588
1589 void checkCompatibility() const
1590 {
1591 assert(TemplateId == templateId());
1592
1593 checkSchema<Schema>(schemaId(), version());
1594 checkLength(bufferSize(), version());
1595 checkVarLenFields();
1596 }
1597
1599 struct PricesAccess
1600 {
1601 Prices operator()(const PriceUpdate& obj) const
1602 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1603 {
1604 return obj.
1605 groups().
1606 head<Prices>();
1607 }
1608 };
1609};
1610
1612ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
1613FullTradeInformation
1614: SbeMessage
1615{
1617 typedef SchemaTraits Schema;
1618
1620 enum { TemplateId = 1004 };
1621
1624 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
1625 NotUsedGroup1Entry : SbeGroupEntry
1626 <
1627 GroupSizeEncoding::BlockLength
1628 >
1629 {
1631 typedef
1632 SbeGroupEntry
1633 <
1634 GroupSizeEncoding::BlockLength
1635 >
1636 Base;
1637
1640 NotUsedGroup1Entry(
1641 const void* data,
1642 EncodedLength length,
1643 SchemaVersion version)
1644 : Base(data, numericCast<Base::BlockLength>(length), version)
1645 {
1646 assert(version >= Schema::MinimalVersion);
1647 assert(length >= minimalBlockLength(version));
1648 }
1649
1652 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1653 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1654 static BlockLength blockLength(SchemaVersion version)
1655 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1656 {
1657 return
1658 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1659 minimalBlockLength(version);
1660 }
1661
1664 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1665 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1666 static
1667 BlockLength
1668 minimalBlockLength(
1669 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
1670 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1671 {
1672 return
1673 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
1674 0;
1675 }
1676
1678 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
1679 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1680 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
1681 static const Char* className()
1682 {
1683 return "FullTradeInformation.NotUsedGroup1Entry";
1684 }
1685 };
1686
1688 typedef
1689 SbeGroup<NotUsedGroup1Entry, GroupSizeEncoding, MessageSize>
1690 NotUsedGroup1;
1691
1693 FullTradeInformation() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
1694
1696 FullTradeInformation(
1697 const void* data,
1698 EncodedLength length)
1699 : SbeMessage(data, length)
1700 {
1701 checkCompatibility();
1702 }
1703
1705 explicit
1706 FullTradeInformation(
1707 const SbeMessage& message)
1708 : SbeMessage(message)
1709 {
1710 assert(message.valid());
1711
1712 checkCompatibility();
1713 }
1714
1716 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1717 bool seqNum(Uint64& value) const
1718 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1719 {
1720 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
1721
1722 return ordinary(value, offset, NullUint64());
1723 }
1724
1726 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1727 bool rebroadcastIndicator(UnsignedChar& value) const
1728 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1729 {
1730 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
1731
1732 return ordinary(value, offset, NullUnsignedChar());
1733 }
1734
1736 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1744
1746 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1747 bool eventTime(Uint64& value) const
1748 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1749 {
1750 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
1751
1752 return ordinary(value, offset, NullUint64());
1753 }
1754
1756 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1757 bool symbolIndex(Uint32& value) const
1758 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1759 {
1760 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 18;
1761
1762 return ordinary(value, offset, NullUint32());
1763 }
1764
1766 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1775
1777 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1786
1788 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1796
1798 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1807
1809 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1818
1820 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1829
1831 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1832 bool mifidPrice(StrRef& value) const
1833 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
1834 {
1835 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 145;
1836 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 20;
1837
1838 return fixedStr<length>(value, offset);
1839 }
1840
1842 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1851
1853 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1862
1864 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1873
1875 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1884
1886 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1895
1897 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1906
1908 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1917
1919 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1928
1930 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1931 bool
1940
1942 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1943 bool
1952
1954 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1963
1965 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1974
1976 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1985
1987 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
1996
1998 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2007
2009 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2018
2020 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2021 bool
2030
2032 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2041
2043 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2052
2054 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2063
2065 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2074
2076 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2085
2087 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2095
2097 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2098 bool
2107
2109 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2110 bool
2119
2121 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2122 bool
2131
2133 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2142
2144 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2145 bool originalReportTimestamp(Uint64& value) const
2146 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2147 {
2148 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 346;
2149
2150 return ordinary(value, offset, NullUint64());
2151 }
2152
2154 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2155 bool
2164
2166 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2167 bool currencyCoefficient(Uint32& value) const
2168 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2169 {
2170 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 355;
2171
2172 return ordinary(value, offset, NullUint32());
2173 }
2174
2176 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2177 bool priceMultiplier(Uint32& value) const
2178 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2179 {
2180 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 359;
2181
2182 return ordinary(value, offset, NullUint32());
2183 }
2184
2186 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2187 bool priceMultiplierDecimals(UnsignedChar& value) const
2188 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2189 {
2190 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 363;
2191
2192 return ordinary(value, offset, NullUnsignedChar());
2193 }
2194
2196 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2205
2207 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2208 bool startTimeVwap(Uint32& value) const
2209 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2210 {
2211 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 375;
2212
2213 return ordinary(value, offset, NullUint32());
2214 }
2215
2217 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2218 bool endTimeVwap(Uint32& value) const
2219 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2220 {
2221 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 379;
2222
2223 return ordinary(value, offset, NullUint32());
2224 }
2225
2227 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2236
2238 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2247
2249 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2250 bool evaluatedPrice(Int64& value) const
2251 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2252 {
2253 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 391;
2254
2255 return ordinary(value, offset, NullInt64());
2256 }
2257
2259 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2260 bool
2269
2271 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2272 bool settlementDate(Uint16& value) const
2273 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2274 {
2275 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 400;
2276
2277 return ordinary(value, offset, NullUint16());
2278 }
2279
2281 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2282 bool repoSettlementDate(Uint16& value) const
2283 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2284 {
2285 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 402;
2286
2287 return ordinary(value, offset, NullUint16());
2288 }
2289
2291 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2301
2303 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2313
2315 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2325
2327 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2337
2339 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2349
2351 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2361
2363 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2373
2375 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2385
2387 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2397
2399 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2400 NotUsedGroup1 notUsedGroup1() const
2401 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2402 {
2403 return getGroup<NotUsedGroup1>(
2404 NotUsedGroup1Access(),
2405 *this);
2406 }
2407
2409 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2410 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2411 static BlockLength minimalBlockLength(SchemaVersion version)
2412 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2413 {
2414 return
2415 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2416 (version >= 353)
2417 ? 452
2418 : (version >= 334)
2419 ? 444
2420 : (version >= 316)
2421 ? 420
2422 : 404;
2423 }
2424
2426 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2427 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2428 static BlockLength blockLength(SchemaVersion version)
2429 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2430 {
2431 return
2432 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2433 minimalBlockLength(version);
2434 }
2435
2437 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2438 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2439 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2440 static
2441 MessageSize
2442 getMinimalVariableFieldsSize(
2443 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
2444 {
2445 return
2446 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2447 static_cast<MessageSize>(NotUsedGroup1::EmptySize);
2448 }
2449
2451 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2452 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2453 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2454 static const Char* className()
2455 {
2456 return "FullTradeInformation";
2457 }
2458
2460 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2461 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2462 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2463 static StrRef fixType()
2464 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2465 {
2466 return constructStrRef("FullTradeInformation");
2467 }
2468
2470 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2471 std::string toString() const;
2472
2473private:
2474 void checkLength(
2475 EncodedLength length, SchemaVersion version) const
2476 {
2477 const EncodedLength minimalRequiredLength =
2478 minimalBlockLength(version) +
2479 MessageHeader::Size +
2480 getMinimalVariableFieldsSize(version);
2481
2482 checkBinaryLength(
2483 *this, length, minimalRequiredLength);
2484 }
2485
2487 void checkVarLenFields() const
2488 {
2489 groups().
2490 checkTail<NotUsedGroup1>();
2491 }
2492
2493 void checkCompatibility() const
2494 {
2495 assert(TemplateId == templateId());
2496
2497 checkSchema<Schema>(schemaId(), version());
2498 checkLength(bufferSize(), version());
2499 checkVarLenFields();
2500 }
2501
2503 struct NotUsedGroup1Access
2504 {
2505 NotUsedGroup1
2506 operator()(
2507 const FullTradeInformation& obj) const
2508 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2509 {
2510 return obj.
2511 groups().
2512 head<NotUsedGroup1>();
2513 }
2514 };
2515};
2516
2518ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
2519MarketStatusChange
2520: SbeMessage
2521{
2523 typedef SchemaTraits Schema;
2524
2526 enum { TemplateId = 1005 };
2527
2530 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
2531 MarketStatesEntry : SbeGroupEntry
2532 <
2533 GroupSizeEncoding::BlockLength
2534 >
2535 {
2537 typedef
2538 SbeGroupEntry
2539 <
2540 GroupSizeEncoding::BlockLength
2541 >
2542 Base;
2543
2546 MarketStatesEntry(
2547 const void* data,
2548 EncodedLength length,
2549 SchemaVersion version)
2550 : Base(data, numericCast<Base::BlockLength>(length), version)
2551 {
2552 assert(version >= Schema::MinimalVersion);
2553 assert(length >= minimalBlockLength(version));
2554 }
2555
2557 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2558 MarketDataChangeType::Enum
2566
2568 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2569 bool symbolIndex(Uint32& value) const
2570 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2571 {
2572 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 1;
2573
2574 return ordinary(value, offset, NullUint32());
2575 }
2576
2578 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2579 bool eventTime(Uint64& value) const
2580 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2581 {
2582 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 5;
2583
2584 return ordinary(value, offset, NullUint64());
2585 }
2586
2588 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2589 bool bookState(BookState::Enum& value) const
2590 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2591 {
2592 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 13;
2593
2594 return enumeration<BookState>(value, offset, NullUInt8());
2595 }
2596
2598 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2599 bool
2608
2610 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2618
2620 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2621 bool
2630
2632 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2633 bool tradingSide(TradingSide::Enum& value) const
2634 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2635 {
2636 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 18;
2637
2638 return enumeration<TradingSide>(value, offset, NullUInt8());
2639 }
2640
2642 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2643 bool priceLimits(PriceLimits::Enum& value) const
2644 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2645 {
2646 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 19;
2647
2648 return enumeration<PriceLimits>(value, offset, NullUInt8());
2649 }
2650
2652 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2653 bool
2662
2664 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2665 bool
2674
2676 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2684
2686 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2687 bool
2696
2698 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2699 bool scheduledEventTime(Uint64& value) const
2700 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2701 {
2702 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 24;
2703
2704 return ordinary(value, offset, NullUint64());
2705 }
2706
2708 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2709 bool
2718
2721 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2722 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2723 static BlockLength blockLength(SchemaVersion version)
2724 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2725 {
2726 return
2727 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2728 minimalBlockLength(version);
2729 }
2730
2733 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2734 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2735 static
2736 BlockLength
2737 minimalBlockLength(
2738 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
2739 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2740 {
2741 return
2742 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2743 33;
2744 }
2745
2747 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2748 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2749 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2750 static const Char* className()
2751 {
2752 return "MarketStatusChange.MarketStatesEntry";
2753 }
2754 };
2755
2757 typedef
2758 SbeGroup<MarketStatesEntry, GroupSizeEncoding, MessageSize>
2759 MarketStates;
2760
2762 MarketStatusChange() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
2763
2765 MarketStatusChange(
2766 const void* data,
2767 EncodedLength length)
2768 : SbeMessage(data, length)
2769 {
2770 checkCompatibility();
2771 }
2772
2774 explicit
2775 MarketStatusChange(
2776 const SbeMessage& message)
2777 : SbeMessage(message)
2778 {
2779 assert(message.valid());
2780
2781 checkCompatibility();
2782 }
2783
2785 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2786 bool seqNum(Uint64& value) const
2787 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2788 {
2789 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
2790
2791 return ordinary(value, offset, NullUint64());
2792 }
2793
2795 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2796 bool rebroadcastIndicator(UnsignedChar& value) const
2797 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2798 {
2799 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
2800
2801 return ordinary(value, offset, NullUnsignedChar());
2802 }
2803
2805 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2813
2815 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2816 MarketStates marketStates() const
2817 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2818 {
2819 return getGroup<MarketStates>(
2820 MarketStatesAccess(),
2821 *this);
2822 }
2823
2825 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2826 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2827 static
2828 BlockLength
2829 minimalBlockLength(
2830 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
2831 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2832 {
2833 return
2834 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2835 10;
2836 }
2837
2839 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2840 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2841 static BlockLength blockLength(SchemaVersion version)
2842 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2843 {
2844 return
2845 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2846 minimalBlockLength(version);
2847 }
2848
2850 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2851 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2852 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2853 static
2854 MessageSize
2855 getMinimalVariableFieldsSize(
2856 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
2857 {
2858 return
2859 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
2860 static_cast<MessageSize>(MarketStates::EmptySize);
2861 }
2862
2864 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2865 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2866 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2867 static const Char* className()
2868 {
2869 return "MarketStatusChange";
2870 }
2871
2873 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
2874 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2875 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
2876 static StrRef fixType()
2877 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2878 {
2879 return constructStrRef("MarketStatusChange");
2880 }
2881
2883 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2884 std::string toString() const;
2885
2886private:
2887 void checkLength(
2888 EncodedLength length, SchemaVersion version) const
2889 {
2890 const EncodedLength minimalRequiredLength =
2891 minimalBlockLength(version) +
2892 MessageHeader::Size +
2893 getMinimalVariableFieldsSize(version);
2894
2895 checkBinaryLength(
2896 *this, length, minimalRequiredLength);
2897 }
2898
2900 void checkVarLenFields() const
2901 {
2902 groups().
2903 checkTail<MarketStates>();
2904 }
2905
2906 void checkCompatibility() const
2907 {
2908 assert(TemplateId == templateId());
2909
2910 checkSchema<Schema>(schemaId(), version());
2911 checkLength(bufferSize(), version());
2912 checkVarLenFields();
2913 }
2914
2916 struct MarketStatesAccess
2917 {
2918 MarketStates
2919 operator()(
2920 const MarketStatusChange& obj) const
2921 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2922 {
2923 return obj.
2924 groups().
2925 head<MarketStates>();
2926 }
2927 };
2928};
2929
2931ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
2932Timetable
2933: SbeMessage
2934{
2936 typedef SchemaTraits Schema;
2937
2939 enum { TemplateId = 1006 };
2940
2943 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
2944 TimetablesEntry : SbeGroupEntry
2945 <
2946 GroupSizeEncoding::BlockLength
2947 >
2948 {
2950 typedef
2951 SbeGroupEntry
2952 <
2953 GroupSizeEncoding::BlockLength
2954 >
2955 Base;
2956
2959 TimetablesEntry(
2960 const void* data,
2961 EncodedLength length,
2962 SchemaVersion version)
2963 : Base(data, numericCast<Base::BlockLength>(length), version)
2964 {
2965 assert(version >= Schema::MinimalVersion);
2966 assert(length >= minimalBlockLength(version));
2967 }
2968
2970 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2971 bool phaseTime(Uint64& value) const
2972 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
2973 {
2974 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
2975
2976 return ordinary(value, offset, NullUint64());
2977 }
2978
2980 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2988
2990 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
2998
3000 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3008
3010 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3011 bool
3020
3022 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3030
3032 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3033 bool
3042
3045 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3046 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3047 static BlockLength blockLength(SchemaVersion version)
3048 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3049 {
3050 return
3051 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3052 minimalBlockLength(version);
3053 }
3054
3057 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3058 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3059 static
3060 BlockLength
3061 minimalBlockLength(
3062 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
3063 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3064 {
3065 return
3066 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3067 15;
3068 }
3069
3071 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3072 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3073 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3074 static const Char* className()
3075 {
3076 return "Timetable.TimetablesEntry";
3077 }
3078 };
3079
3081 typedef
3082 SbeGroup<TimetablesEntry, GroupSizeEncoding, MessageSize>
3083 Timetables;
3084
3086 Timetable() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
3087
3089 Timetable(
3090 const void* data,
3091 EncodedLength length)
3092 : SbeMessage(data, length)
3093 {
3094 checkCompatibility();
3095 }
3096
3098 explicit
3099 Timetable(
3100 const SbeMessage& message)
3101 : SbeMessage(message)
3102 {
3103 assert(message.valid());
3104
3105 checkCompatibility();
3106 }
3107
3109 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3110 bool seqNum(Uint64& value) const
3111 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3112 {
3113 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
3114
3115 return ordinary(value, offset, NullUint64());
3116 }
3117
3119 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3120 bool rebroadcastIndicator(UnsignedChar& value) const
3121 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3122 {
3123 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
3124
3125 return ordinary(value, offset, NullUnsignedChar());
3126 }
3127
3129 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3130 bool eMM(Emm::Enum& value) const
3131 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3132 {
3133 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
3134
3135 return enumeration<Emm>(value, offset, NullUInt8());
3136 }
3137
3139 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3140 bool patternId(Uint16& value) const
3141 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3142 {
3143 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
3144
3145 return ordinary(value, offset, NullUint16());
3146 }
3147
3149 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3150 bool symbolIndex(Uint32& value) const
3151 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3152 {
3153 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 12;
3154
3155 return ordinary(value, offset, NullUint32());
3156 }
3157
3159 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3160 Timetables timetables() const
3161 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3162 {
3163 return getGroup<Timetables>(
3164 TimetablesAccess(),
3165 *this);
3166 }
3167
3169 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3170 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3171 static
3172 BlockLength
3173 minimalBlockLength(
3174 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
3175 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3176 {
3177 return
3178 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3179 16;
3180 }
3181
3183 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3184 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3185 static BlockLength blockLength(SchemaVersion version)
3186 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3187 {
3188 return
3189 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3190 minimalBlockLength(version);
3191 }
3192
3194 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3195 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3196 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3197 static
3198 MessageSize
3199 getMinimalVariableFieldsSize(
3200 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
3201 {
3202 return
3203 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3204 static_cast<MessageSize>(Timetables::EmptySize);
3205 }
3206
3208 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3209 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3210 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3211 static const Char* className()
3212 {
3213 return "Timetable";
3214 }
3215
3217 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3218 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3219 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3220 static StrRef fixType()
3221 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3222 {
3223 return constructStrRef("Timetable");
3224 }
3225
3227 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3228 std::string toString() const;
3229
3230private:
3231 void checkLength(
3232 EncodedLength length, SchemaVersion version) const
3233 {
3234 const EncodedLength minimalRequiredLength =
3235 minimalBlockLength(version) +
3236 MessageHeader::Size +
3237 getMinimalVariableFieldsSize(version);
3238
3239 checkBinaryLength(
3240 *this, length, minimalRequiredLength);
3241 }
3242
3244 void checkVarLenFields() const
3245 {
3246 groups().
3247 checkTail<Timetables>();
3248 }
3249
3250 void checkCompatibility() const
3251 {
3252 assert(TemplateId == templateId());
3253
3254 checkSchema<Schema>(schemaId(), version());
3255 checkLength(bufferSize(), version());
3256 checkVarLenFields();
3257 }
3258
3260 struct TimetablesAccess
3261 {
3262 Timetables operator()(const Timetable& obj) const
3263 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3264 {
3265 return obj.
3266 groups().
3267 head<Timetables>();
3268 }
3269 };
3270};
3271
3273ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
3274StandingData
3275: SbeMessage
3276{
3278 typedef SchemaTraits Schema;
3279
3281 enum { TemplateId = 1007 };
3282
3285 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
3286 EmmPatternRepEntry : SbeGroupEntry
3287 <
3288 GroupSizeEncoding::BlockLength
3289 >
3290 {
3292 typedef
3293 SbeGroupEntry
3294 <
3295 GroupSizeEncoding::BlockLength
3296 >
3297 Base;
3298
3301 EmmPatternRepEntry(
3302 const void* data,
3303 EncodedLength length,
3304 SchemaVersion version)
3305 : Base(data, numericCast<Base::BlockLength>(length), version)
3306 {
3307 assert(version >= Schema::MinimalVersion);
3308 assert(length >= minimalBlockLength(version));
3309 }
3310
3312 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3320
3322 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3323 bool patternId(Uint16& value) const
3324 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3325 {
3326 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 1;
3327
3328 return ordinary(value, offset, NullUint16());
3329 }
3330
3332 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3333 bool tickSizeIndexId(Uint16& value) const
3334 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3335 {
3336 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 3;
3337
3338 return ordinary(value, offset, NullUint16());
3339 }
3340
3342 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3350
3352 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3353 bool lotSize(Uint64& value) const
3354 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3355 {
3356 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 6;
3357
3358 return ordinary(value, offset, NullUint64());
3359 }
3360
3362 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3363 bool
3372
3374 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3375 bool anonymous(Anonymous::Enum& value) const
3376 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3377 {
3378 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 15;
3379
3380 return enumeration<Anonymous>(value, offset, NullUInt8());
3381 }
3382
3385 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3386 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3387 static BlockLength blockLength(SchemaVersion version)
3388 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3389 {
3390 return
3391 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3392 minimalBlockLength(version);
3393 }
3394
3397 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3398 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3399 static
3400 BlockLength
3401 minimalBlockLength(
3402 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
3403 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3404 {
3405 return
3406 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
3407 16;
3408 }
3409
3411 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
3412 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3413 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
3414 static const Char* className()
3415 {
3416 return "StandingData.EmmPatternRepEntry";
3417 }
3418 };
3419
3421 typedef
3422 SbeGroup<EmmPatternRepEntry, GroupSizeEncoding, MessageSize>
3423 EmmPatternRep;
3424
3426 StandingData() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
3427
3429 StandingData(
3430 const void* data,
3431 EncodedLength length)
3432 : SbeMessage(data, length)
3433 {
3434 checkCompatibility();
3435 }
3436
3438 explicit
3439 StandingData(
3440 const SbeMessage& message)
3441 : SbeMessage(message)
3442 {
3443 assert(message.valid());
3444
3445 checkCompatibility();
3446 }
3447
3449 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3450 bool seqNum(Uint64& value) const
3451 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3452 {
3453 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
3454
3455 return ordinary(value, offset, NullUint64());
3456 }
3457
3459 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3460 bool rebroadcastIndicator(UnsignedChar& value) const
3461 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3462 {
3463 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
3464
3465 return ordinary(value, offset, NullUnsignedChar());
3466 }
3467
3469 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3470 bool symbolIndex(Uint32& value) const
3471 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3472 {
3473 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
3474
3475 return ordinary(value, offset, NullUint32());
3476 }
3477
3479 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3487
3489 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3490 bool partitionId(Uint16& value) const
3491 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3492 {
3493 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 14;
3494
3495 return ordinary(value, offset, NullUint16());
3496 }
3497
3499 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3508
3510 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3519
3521 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3530
3532 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3541
3543 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3552
3554 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3555 bool priceDecimals(UnsignedChar& value) const
3556 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3557 {
3558 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 165;
3559
3560 return ordinary(value, offset, NullUnsignedChar());
3561 }
3562
3564 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3565 bool quantityDecimals(UnsignedChar& value) const
3566 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3567 {
3568 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 166;
3569
3570 return ordinary(value, offset, NullUnsignedChar());
3571 }
3572
3574 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3575 bool amountDecimals(UnsignedChar& value) const
3576 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3577 {
3578 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 167;
3579
3580 return ordinary(value, offset, NullUnsignedChar());
3581 }
3582
3584 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3585 bool ratioDecimals(UnsignedChar& value) const
3586 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3587 {
3588 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 168;
3589
3590 return ordinary(value, offset, NullUnsignedChar());
3591 }
3592
3594 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3603
3605 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3606 bool instrumentEventDate(Uint16& value) const
3607 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3608 {
3609 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 175;
3610
3611 return ordinary(value, offset, NullUint16());
3612 }
3613
3615 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3616 bool strikePrice(Int64& value) const
3617 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3618 {
3619 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 177;
3620
3621 return ordinary(value, offset, NullInt64());
3622 }
3623
3625 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3626 bool darkEligibility(UnsignedChar& value) const
3627 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3628 {
3629 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 185;
3630
3631 return ordinary(value, offset, NullUnsignedChar());
3632 }
3633
3635 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3636 bool darkLISThreshold(Uint64& value) const
3637 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3638 {
3639 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 186;
3640
3641 return ordinary(value, offset, NullUint64());
3642 }
3643
3645 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3646 bool darkMinQuantity(Uint32& value) const
3647 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3648 {
3649 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 194;
3650
3651 return ordinary(value, offset, NullUint32());
3652 }
3653
3655 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3656 bool dateOfLastTrade(Uint16& value) const
3657 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3658 {
3659 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 198;
3660
3661 return ordinary(value, offset, NullUint16());
3662 }
3663
3665 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3674
3676 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3685
3687 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3688 bool firstSettlementDate(Uint16& value) const
3689 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3690 {
3691 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 225;
3692
3693 return ordinary(value, offset, NullUint16());
3694 }
3695
3697 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3698 bool
3707
3709 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3710 bool iCB(StrRef& value) const
3711 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3712 {
3713 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 228;
3714 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 16;
3715
3716 return fixedStr<length>(value, offset);
3717 }
3718
3720 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3729
3731 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3732 bool lastAdjustedClosingPrice(Int64& value) const
3733 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3734 {
3735 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 247;
3736
3737 return ordinary(value, offset, NullInt64());
3738 }
3739
3741 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3742 bool lotSize(Uint64& value) const
3743 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3744 {
3745 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 255;
3746
3747 return ordinary(value, offset, NullUint64());
3748 }
3749
3751 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3760
3762 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3763 bool maximumDecimalsInQuantity(UnsignedChar& value) const
3764 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3765 {
3766 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 271;
3767
3768 return ordinary(value, offset, NullUnsignedChar());
3769 }
3770
3772 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3781
3783 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3784 bool mICList(StrRef& value) const
3785 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3786 {
3787 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 276;
3788 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 20;
3789
3790 return fixedStr<length>(value, offset);
3791 }
3792
3794 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3803
3805 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3806 bool mnemonic(StrRef& value) const
3807 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3808 {
3809 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 299;
3810 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 5;
3811
3812 return fixedStr<length>(value, offset);
3813 }
3814
3816 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3825
3827 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3836
3838 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3847
3849 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3850 bool currencyCoefficient(Uint32& value) const
3851 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3852 {
3853 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 323;
3854
3855 return ordinary(value, offset, NullUint32());
3856 }
3857
3859 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3860 bool
3869
3871 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3872 bool
3881
3883 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3884 bool numberInstrumentCirculating(Uint64& value) const
3885 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3886 {
3887 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 329;
3888
3889 return ordinary(value, offset, NullUint64());
3890 }
3891
3893 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3894 bool parValue(Uint64& value) const
3895 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3896 {
3897 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 337;
3898
3899 return ordinary(value, offset, NullUint64());
3900 }
3901
3903 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3912
3914 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3915 bool
3924
3926 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3935
3937 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3946
3948 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3949 bool taxCode(TaxCode::Enum& value) const
3950 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3951 {
3952 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 354;
3953
3954 return enumeration<TaxCode>(value, offset, NullUInt8());
3955 }
3956
3958 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3967
3969 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3970 bool
3979
3981 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3982 bool
3991
3993 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
3994 bool issuePrice(Int64& value) const
3995 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
3996 {
3997 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 359;
3998
3999 return ordinary(value, offset, NullInt64());
4000 }
4001
4003 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4012
4014 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4015 bool issuePriceDecimals(UnsignedChar& value) const
4016 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4017 {
4018 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 370;
4019
4020 return ordinary(value, offset, NullUnsignedChar());
4021 }
4022
4024 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4025 bool strikePriceDecimals(UnsignedChar& value) const
4026 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4027 {
4028 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 371;
4029
4030 return ordinary(value, offset, NullUnsignedChar());
4031 }
4032
4034 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4035 bool liquidInstrumentIndicator(UnsignedChar& value) const
4036 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4037 {
4038 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 372;
4039
4040 return ordinary(value, offset, NullUnsignedChar());
4041 }
4042
4044 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4053
4055 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4056 bool iCBCode(StrRef& value) const
4057 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4058 {
4059 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 377;
4060 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 8;
4061
4062 return fixedStr<length>(value, offset);
4063 }
4064
4066 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4067 bool thresholdLISPostTrade60mn(Uint64& value) const
4068 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4069 {
4070 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 385;
4071
4072 return ordinary(value, offset, NullUint64());
4073 }
4074
4076 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4077 bool thresholdLISPostTrade120mn(Uint64& value) const
4078 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4079 {
4080 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 393;
4081
4082 return ordinary(value, offset, NullUint64());
4083 }
4084
4086 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4087 bool thresholdLISPostTradeEOD(Uint64& value) const
4088 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4089 {
4090 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 401;
4091
4092 return ordinary(value, offset, NullUint64());
4093 }
4094
4096 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4106
4108 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4109 bool maxOrderAmountCall(Uint64& value) const
4110 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4111 {
4112 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 415;
4113 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR SchemaVersion since = 318;
4114
4115 return ordinary(value, offset, NullUint64(), since);
4116 }
4117
4119 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4120 bool maxOrderAmountContinuous(Uint64& value) const
4121 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4122 {
4123 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 423;
4124 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR SchemaVersion since = 318;
4125
4126 return ordinary(value, offset, NullUint64(), since);
4127 }
4128
4130 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4131 bool maxOrderQuantityCall(Uint64& value) const
4132 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4133 {
4134 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 431;
4135 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR SchemaVersion since = 318;
4136
4137 return ordinary(value, offset, NullUint64(), since);
4138 }
4139
4141 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4150
4152 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4153 bool poolFactor(Uint32& value) const
4154 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4155 {
4156 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 447;
4157 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR SchemaVersion since = 318;
4158
4159 return ordinary(value, offset, NullUint32(), since);
4160 }
4161
4163 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4164 EmmPatternRep emmPatternRep() const
4165 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4166 {
4167 return getGroup<EmmPatternRep>(
4168 EmmPatternRepAccess(),
4169 *this);
4170 }
4171
4173 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4174 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4175 static BlockLength minimalBlockLength(SchemaVersion version)
4176 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4177 {
4178 return
4179 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4180 (version >= 318)
4181 ? 451
4182 : (version >= 316)
4183 ? 415
4184 : 409;
4185 }
4186
4188 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4189 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4190 static BlockLength blockLength(SchemaVersion version)
4191 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4192 {
4193 return
4194 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4195 minimalBlockLength(version);
4196 }
4197
4199 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4200 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4201 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4202 static
4203 MessageSize
4204 getMinimalVariableFieldsSize(
4205 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4206 {
4207 return
4208 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4209 static_cast<MessageSize>(EmmPatternRep::EmptySize);
4210 }
4211
4213 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4214 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4215 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4216 static const Char* className()
4217 {
4218 return "StandingData";
4219 }
4220
4222 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4223 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4224 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4225 static StrRef fixType()
4226 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4227 {
4228 return constructStrRef("StandingData");
4229 }
4230
4232 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4233 std::string toString() const;
4234
4235private:
4236 void checkLength(
4237 EncodedLength length, SchemaVersion version) const
4238 {
4239 const EncodedLength minimalRequiredLength =
4240 minimalBlockLength(version) +
4241 MessageHeader::Size +
4242 getMinimalVariableFieldsSize(version);
4243
4244 checkBinaryLength(
4245 *this, length, minimalRequiredLength);
4246 }
4247
4249 void checkVarLenFields() const
4250 {
4251 groups().
4252 checkTail<EmmPatternRep>();
4253 }
4254
4255 void checkCompatibility() const
4256 {
4257 assert(TemplateId == templateId());
4258
4259 checkSchema<Schema>(schemaId(), version());
4260 checkLength(bufferSize(), version());
4261 checkVarLenFields();
4262 }
4263
4265 struct EmmPatternRepAccess
4266 {
4267 EmmPatternRep operator()(const StandingData& obj) const
4268 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4269 {
4270 return obj.
4271 groups().
4272 head<EmmPatternRep>();
4273 }
4274 };
4275};
4276
4278ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
4279RealTimeIndex
4280: SbeMessage
4281{
4283 typedef SchemaTraits Schema;
4284
4286 enum { TemplateId = 1008 };
4287
4289 RealTimeIndex() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
4290
4292 RealTimeIndex(
4293 const void* data,
4294 EncodedLength length)
4295 : SbeMessage(data, length)
4296 {
4297 checkCompatibility();
4298 }
4299
4301 explicit
4302 RealTimeIndex(
4303 const SbeMessage& message)
4304 : SbeMessage(message)
4305 {
4306 assert(message.valid());
4307
4308 checkCompatibility();
4309 }
4310
4312 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4313 bool seqNum(Uint64& value) const
4314 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4315 {
4316 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
4317
4318 return ordinary(value, offset, NullUint64());
4319 }
4320
4322 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4323 bool rebroadcastIndicator(UnsignedChar& value) const
4324 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4325 {
4326 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
4327
4328 return ordinary(value, offset, NullUnsignedChar());
4329 }
4330
4332 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4340
4342 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4343 bool eventTime(Uint64& value) const
4344 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4345 {
4346 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
4347
4348 return ordinary(value, offset, NullUint64());
4349 }
4350
4352 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4353 bool symbolIndex(Uint32& value) const
4354 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4355 {
4356 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 18;
4357
4358 return ordinary(value, offset, NullUint32());
4359 }
4360
4362 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4363 bool indexLevel(Int64& value) const
4364 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4365 {
4366 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 22;
4367
4368 return ordinary(value, offset, NullInt64());
4369 }
4370
4372 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4373 bool pctgOfCapitalization(Uint64& value) const
4374 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4375 {
4376 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 30;
4377
4378 return ordinary(value, offset, NullUint64());
4379 }
4380
4382 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4383 bool prctVarfromPrevClose(Int64& value) const
4384 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4385 {
4386 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 38;
4387
4388 return ordinary(value, offset, NullInt64());
4389 }
4390
4392 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4393 bool numTradedInstruments(Uint16& value) const
4394 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4395 {
4396 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 46;
4397
4398 return ordinary(value, offset, NullUint16());
4399 }
4400
4402 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4410
4412 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4420
4422 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4423 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4424 static
4425 BlockLength
4426 minimalBlockLength(
4427 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4428 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4429 {
4430 return
4431 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4432 50;
4433 }
4434
4436 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4437 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4438 static BlockLength blockLength(SchemaVersion version)
4439 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4440 {
4441 return
4442 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4443 minimalBlockLength(version);
4444 }
4445
4447 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4448 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4449 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4450 static
4451 MessageSize
4452 getMinimalVariableFieldsSize(
4453 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4454 {
4455 return
4456 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4457 0;
4458 }
4459
4461 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4462 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4463 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4464 static const Char* className()
4465 {
4466 return "RealTimeIndex";
4467 }
4468
4470 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4471 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4472 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4473 static StrRef fixType()
4474 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4475 {
4476 return constructStrRef("RealTimeIndex");
4477 }
4478
4480 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4481 std::string toString() const;
4482
4483private:
4484 void checkLength(
4485 EncodedLength length, SchemaVersion version) const
4486 {
4487 const EncodedLength minimalRequiredLength =
4488 minimalBlockLength(version) +
4489 MessageHeader::Size +
4490 getMinimalVariableFieldsSize(version);
4491
4492 checkBinaryLength(
4493 *this, length, minimalRequiredLength);
4494 }
4495
4496 void checkCompatibility() const
4497 {
4498 assert(TemplateId == templateId());
4499
4500 checkSchema<Schema>(schemaId(), version());
4501 checkLength(bufferSize(), version());
4502 }
4503};
4504
4506ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
4507Statistics
4508: SbeMessage
4509{
4511 typedef SchemaTraits Schema;
4512
4514 enum { TemplateId = 1009 };
4515
4518 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
4519 NewStatsEntry : SbeGroupEntry
4520 <
4521 GroupSizeEncoding::BlockLength
4522 >
4523 {
4525 typedef
4526 SbeGroupEntry
4527 <
4528 GroupSizeEncoding::BlockLength
4529 >
4530 Base;
4531
4534 NewStatsEntry(
4535 const void* data,
4536 EncodedLength length,
4537 SchemaVersion version)
4538 : Base(data, numericCast<Base::BlockLength>(length), version)
4539 {
4540 assert(version >= Schema::MinimalVersion);
4541 assert(length >= minimalBlockLength(version));
4542 }
4543
4545 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4553
4555 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4556 bool statsUpdateValue(Int64& value) const
4557 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4558 {
4559 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 1;
4560
4561 return ordinary(value, offset, NullInt64());
4562 }
4563
4566 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4567 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4568 static BlockLength blockLength(SchemaVersion version)
4569 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4570 {
4571 return
4572 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4573 minimalBlockLength(version);
4574 }
4575
4578 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4579 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4580 static
4581 BlockLength
4582 minimalBlockLength(
4583 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4584 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4585 {
4586 return
4587 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4588 9;
4589 }
4590
4592 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4593 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4594 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4595 static const Char* className()
4596 {
4597 return "Statistics.NewStatsEntry";
4598 }
4599 };
4600
4602 typedef
4603 SbeGroup<NewStatsEntry, GroupSizeEncoding, MessageSize>
4604 NewStats;
4605
4607 Statistics() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
4608
4610 Statistics(
4611 const void* data,
4612 EncodedLength length)
4613 : SbeMessage(data, length)
4614 {
4615 checkCompatibility();
4616 }
4617
4619 explicit
4620 Statistics(
4621 const SbeMessage& message)
4622 : SbeMessage(message)
4623 {
4624 assert(message.valid());
4625
4626 checkCompatibility();
4627 }
4628
4630 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4631 bool seqNum(Uint64& value) const
4632 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4633 {
4634 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
4635
4636 return ordinary(value, offset, NullUint64());
4637 }
4638
4640 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4641 bool rebroadcastIndicator(UnsignedChar& value) const
4642 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4643 {
4644 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
4645
4646 return ordinary(value, offset, NullUnsignedChar());
4647 }
4648
4650 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4651 bool symbolIndex(Uint32& value) const
4652 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4653 {
4654 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
4655
4656 return ordinary(value, offset, NullUint32());
4657 }
4658
4660 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4661 NewStats newStats() const
4662 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4663 {
4664 return getGroup<NewStats>(NewStatsAccess(), *this);
4665 }
4666
4668 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4669 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4670 static
4671 BlockLength
4672 minimalBlockLength(
4673 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4674 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4675 {
4676 return
4677 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4678 13;
4679 }
4680
4682 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4683 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4684 static BlockLength blockLength(SchemaVersion version)
4685 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4686 {
4687 return
4688 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4689 minimalBlockLength(version);
4690 }
4691
4693 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4694 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4695 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4696 static
4697 MessageSize
4698 getMinimalVariableFieldsSize(
4699 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4700 {
4701 return
4702 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4703 static_cast<MessageSize>(NewStats::EmptySize);
4704 }
4705
4707 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4708 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4709 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4710 static const Char* className()
4711 {
4712 return "Statistics";
4713 }
4714
4716 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4717 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4718 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4719 static StrRef fixType()
4720 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4721 {
4722 return constructStrRef("Statistics");
4723 }
4724
4726 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4727 std::string toString() const;
4728
4729private:
4730 void checkLength(
4731 EncodedLength length, SchemaVersion version) const
4732 {
4733 const EncodedLength minimalRequiredLength =
4734 minimalBlockLength(version) +
4735 MessageHeader::Size +
4736 getMinimalVariableFieldsSize(version);
4737
4738 checkBinaryLength(
4739 *this, length, minimalRequiredLength);
4740 }
4741
4743 void checkVarLenFields() const
4744 {
4745 groups().
4746 checkTail<NewStats>();
4747 }
4748
4749 void checkCompatibility() const
4750 {
4751 assert(TemplateId == templateId());
4752
4753 checkSchema<Schema>(schemaId(), version());
4754 checkLength(bufferSize(), version());
4755 checkVarLenFields();
4756 }
4757
4759 struct NewStatsAccess
4760 {
4761 NewStats operator()(const Statistics& obj) const
4762 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4763 {
4764 return obj.
4765 groups().
4766 head<NewStats>();
4767 }
4768 };
4769};
4770
4772ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
4773IndexSummary
4774: SbeMessage
4775{
4777 typedef SchemaTraits Schema;
4778
4780 enum { TemplateId = 1011 };
4781
4783 IndexSummary() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
4784
4786 IndexSummary(
4787 const void* data,
4788 EncodedLength length)
4789 : SbeMessage(data, length)
4790 {
4791 checkCompatibility();
4792 }
4793
4795 explicit
4796 IndexSummary(
4797 const SbeMessage& message)
4798 : SbeMessage(message)
4799 {
4800 assert(message.valid());
4801
4802 checkCompatibility();
4803 }
4804
4806 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4807 bool seqNum(Uint64& value) const
4808 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4809 {
4810 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
4811
4812 return ordinary(value, offset, NullUint64());
4813 }
4814
4816 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4817 bool rebroadcastIndicator(UnsignedChar& value) const
4818 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4819 {
4820 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
4821
4822 return ordinary(value, offset, NullUnsignedChar());
4823 }
4824
4826 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4834
4836 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4837 bool eventTime(Uint64& value) const
4838 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4839 {
4840 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
4841
4842 return ordinary(value, offset, NullUint64());
4843 }
4844
4846 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4847 bool symbolIndex(Uint32& value) const
4848 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4849 {
4850 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 18;
4851
4852 return ordinary(value, offset, NullUint32());
4853 }
4854
4856 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4857 bool openingLevel(Int64& value) const
4858 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4859 {
4860 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 22;
4861
4862 return ordinary(value, offset, NullInt64());
4863 }
4864
4866 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4867 bool openingTime(Uint64& value) const
4868 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4869 {
4870 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 30;
4871
4872 return ordinary(value, offset, NullUint64());
4873 }
4874
4876 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4877 bool confirmedReferenceLevel(Int64& value) const
4878 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4879 {
4880 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 38;
4881
4882 return ordinary(value, offset, NullInt64());
4883 }
4884
4886 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4887 bool confirmedReferenceTime(Uint64& value) const
4888 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4889 {
4890 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 46;
4891
4892 return ordinary(value, offset, NullUint64());
4893 }
4894
4896 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4897 bool closingReferenceLevel(Int64& value) const
4898 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4899 {
4900 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 54;
4901
4902 return ordinary(value, offset, NullInt64());
4903 }
4904
4906 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4907 bool closingReferenceTime(Uint64& value) const
4908 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4909 {
4910 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 62;
4911
4912 return ordinary(value, offset, NullUint64());
4913 }
4914
4916 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4917 bool prctVarfromPrevClose(Int64& value) const
4918 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4919 {
4920 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 70;
4921
4922 return ordinary(value, offset, NullInt64());
4923 }
4924
4926 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4927 bool highLevel(Int64& value) const
4928 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4929 {
4930 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 78;
4931
4932 return ordinary(value, offset, NullInt64());
4933 }
4934
4936 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4937 bool highTime(Uint64& value) const
4938 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4939 {
4940 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 86;
4941
4942 return ordinary(value, offset, NullUint64());
4943 }
4944
4946 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4947 bool lowLevel(Int64& value) const
4948 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4949 {
4950 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 94;
4951
4952 return ordinary(value, offset, NullInt64());
4953 }
4954
4956 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4957 bool lowTime(Uint64& value) const
4958 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4959 {
4960 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 102;
4961
4962 return ordinary(value, offset, NullUint64());
4963 }
4964
4966 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4967 bool liquidationLevel(Int64& value) const
4968 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4969 {
4970 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 110;
4971
4972 return ordinary(value, offset, NullInt64());
4973 }
4974
4976 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
4977 bool liquidationTime(Uint64& value) const
4978 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4979 {
4980 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 118;
4981
4982 return ordinary(value, offset, NullUint64());
4983 }
4984
4986 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
4987 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
4988 static
4989 BlockLength
4990 minimalBlockLength(
4991 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
4992 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
4993 {
4994 return
4995 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
4996 126;
4997 }
4998
5000 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5001 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5002 static BlockLength blockLength(SchemaVersion version)
5003 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5004 {
5005 return
5006 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5007 minimalBlockLength(version);
5008 }
5009
5011 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5012 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5013 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5014 static
5015 MessageSize
5016 getMinimalVariableFieldsSize(
5017 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5018 {
5019 return
5020 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5021 0;
5022 }
5023
5025 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5026 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5027 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5028 static const Char* className()
5029 {
5030 return "IndexSummary";
5031 }
5032
5034 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5035 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5036 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5037 static StrRef fixType()
5038 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5039 {
5040 return constructStrRef("IndexSummary");
5041 }
5042
5044 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5045 std::string toString() const;
5046
5047private:
5048 void checkLength(
5049 EncodedLength length, SchemaVersion version) const
5050 {
5051 const EncodedLength minimalRequiredLength =
5052 minimalBlockLength(version) +
5053 MessageHeader::Size +
5054 getMinimalVariableFieldsSize(version);
5055
5056 checkBinaryLength(
5057 *this, length, minimalRequiredLength);
5058 }
5059
5060 void checkCompatibility() const
5061 {
5062 assert(TemplateId == templateId());
5063
5064 checkSchema<Schema>(schemaId(), version());
5065 checkLength(bufferSize(), version());
5066 }
5067};
5068
5070ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
5071StrategyStandingData
5072: SbeMessage
5073{
5075 typedef SchemaTraits Schema;
5076
5078 enum { TemplateId = 1012 };
5079
5082 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
5083 StrategyStandingDatarep1Entry : SbeGroupEntry
5084 <
5085 GroupSizeEncoding::BlockLength
5086 >
5087 {
5089 typedef
5090 SbeGroupEntry
5091 <
5092 GroupSizeEncoding::BlockLength
5093 >
5094 Base;
5095
5098 StrategyStandingDatarep1Entry(
5099 const void* data,
5100 EncodedLength length,
5101 SchemaVersion version)
5102 : Base(data, numericCast<Base::BlockLength>(length), version)
5103 {
5104 assert(version >= Schema::MinimalVersion);
5105 assert(length >= minimalBlockLength(version));
5106 }
5107
5109 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5110 bool legSymbolIndex(Uint32& value) const
5111 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5112 {
5113 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
5114
5115 return ordinary(value, offset, NullUint32());
5116 }
5117
5119 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5120 bool legPrice(Int64& value) const
5121 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5122 {
5123 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 4;
5124
5125 return ordinary(value, offset, NullInt64());
5126 }
5127
5129 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5130 bool legRatio(Uint32& value) const
5131 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5132 {
5133 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 12;
5134
5135 return ordinary(value, offset, NullUint32());
5136 }
5137
5139 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5147
5150 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5151 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5152 static BlockLength blockLength(SchemaVersion version)
5153 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5154 {
5155 return
5156 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5157 minimalBlockLength(version);
5158 }
5159
5162 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5163 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5164 static
5165 BlockLength
5166 minimalBlockLength(
5167 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5168 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5169 {
5170 return
5171 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5172 17;
5173 }
5174
5176 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5177 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5178 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5179 static const Char* className()
5180 {
5181 return "StrategyStandingData.StrategyStandingDatarep1Entry";
5182 }
5183 };
5184
5186 typedef
5187 SbeGroup<StrategyStandingDatarep1Entry, GroupSizeEncoding, MessageSize>
5188 StrategyStandingDatarep1;
5189
5191 StrategyStandingData() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
5192
5194 StrategyStandingData(
5195 const void* data,
5196 EncodedLength length)
5197 : SbeMessage(data, length)
5198 {
5199 checkCompatibility();
5200 }
5201
5203 explicit
5204 StrategyStandingData(
5205 const SbeMessage& message)
5206 : SbeMessage(message)
5207 {
5208 assert(message.valid());
5209
5210 checkCompatibility();
5211 }
5212
5214 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5215 bool seqNum(Uint64& value) const
5216 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5217 {
5218 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
5219
5220 return ordinary(value, offset, NullUint64());
5221 }
5222
5224 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5225 bool rebroadcastIndicator(UnsignedChar& value) const
5226 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5227 {
5228 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
5229
5230 return ordinary(value, offset, NullUnsignedChar());
5231 }
5232
5234 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5242
5244 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5245 bool symbolIndex(Uint32& value) const
5246 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5247 {
5248 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
5249
5250 return ordinary(value, offset, NullUint32());
5251 }
5252
5254 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5263
5265 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5273
5275 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5284
5286 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5294
5296 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5297 bool contractSymbolIndex(Uint32& value) const
5298 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5299 {
5300 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 42;
5301
5302 return ordinary(value, offset, NullUint32());
5303 }
5304
5306 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5307 bool cFI(StrRef& value) const
5308 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5309 {
5310 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 46;
5311 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 6;
5312
5313 return fixedStr<length>(value, offset);
5314 }
5315
5317 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5318 StrategyStandingDatarep1 strategyStandingDatarep1() const
5319 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5320 {
5321 return getGroup<StrategyStandingDatarep1>(
5322 StrategyStandingDatarep1Access(),
5323 *this);
5324 }
5325
5327 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5328 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5329 static
5330 BlockLength
5331 minimalBlockLength(
5332 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5333 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5334 {
5335 return
5336 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5337 52;
5338 }
5339
5341 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5342 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5343 static BlockLength blockLength(SchemaVersion version)
5344 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5345 {
5346 return
5347 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5348 minimalBlockLength(version);
5349 }
5350
5352 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5353 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5354 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5355 static
5356 MessageSize
5364
5366 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5367 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5368 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5369 static const Char* className()
5370 {
5371 return "StrategyStandingData";
5372 }
5373
5375 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5376 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5377 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5378 static StrRef fixType()
5379 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5380 {
5381 return constructStrRef("StrategyStandingData");
5382 }
5383
5385 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5386 std::string toString() const;
5387
5388private:
5389 void checkLength(
5390 EncodedLength length, SchemaVersion version) const
5391 {
5392 const EncodedLength minimalRequiredLength =
5393 minimalBlockLength(version) +
5394 MessageHeader::Size +
5395 getMinimalVariableFieldsSize(version);
5396
5397 checkBinaryLength(
5398 *this, length, minimalRequiredLength);
5399 }
5400
5402 void checkVarLenFields() const
5403 {
5404 groups().
5405 checkTail<StrategyStandingDatarep1>();
5406 }
5407
5408 void checkCompatibility() const
5409 {
5410 assert(TemplateId == templateId());
5411
5412 checkSchema<Schema>(schemaId(), version());
5413 checkLength(bufferSize(), version());
5414 checkVarLenFields();
5415 }
5416
5418 struct StrategyStandingDatarep1Access
5419 {
5420 StrategyStandingDatarep1
5421 operator()(
5422 const StrategyStandingData& obj) const
5423 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5424 {
5425 return obj.
5426 groups().
5427 head<StrategyStandingDatarep1>();
5428 }
5429 };
5430};
5431
5433ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
5434ContractStandingData
5435: SbeMessage
5436{
5438 typedef SchemaTraits Schema;
5439
5441 enum { TemplateId = 1013 };
5442
5445 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
5446 ContractEMMPropertiesEntry : SbeGroupEntry
5447 <
5448 GroupSizeEncoding::BlockLength
5449 >
5450 {
5452 typedef
5453 SbeGroupEntry
5454 <
5455 GroupSizeEncoding::BlockLength
5456 >
5457 Base;
5458
5461 ContractEMMPropertiesEntry(
5462 const void* data,
5463 EncodedLength length,
5464 SchemaVersion version)
5465 : Base(data, numericCast<Base::BlockLength>(length), version)
5466 {
5467 assert(version >= Schema::MinimalVersion);
5468 assert(length >= minimalBlockLength(version));
5469 }
5470
5472 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5473 bool eMM(Emm::Enum& value) const
5474 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5475 {
5476 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
5477
5478 return enumeration<Emm>(value, offset, NullUInt8());
5479 }
5480
5482 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5483 bool tickSizeIndexId(Uint16& value) const
5484 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5485 {
5486 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 1;
5487
5488 return ordinary(value, offset, NullUint16());
5489 }
5490
5492 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5493 bool patternId(Uint16& value) const
5494 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5495 {
5496 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 3;
5497
5498 return ordinary(value, offset, NullUint16());
5499 }
5500
5502 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5503 bool lotSize(Uint64& value) const
5504 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5505 {
5506 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 5;
5507
5508 return ordinary(value, offset, NullUint64());
5509 }
5510
5512 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5513 bool
5514 strategyAuthorized(
5515 StrategyAuthorized& value) const
5516 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5517 {
5518 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 13;
5519
5520 return ordinary(value, offset, NullUInt64());
5521 }
5522
5524 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5525 bool
5534
5536 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5537 bool collarMaxUnhaltNb(UnsignedChar& value) const
5538 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5539 {
5540 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 22;
5541
5542 return ordinary(value, offset, NullUnsignedChar());
5543 }
5544
5546 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5547 bool collarUnhaltDelay(Uint32& value) const
5548 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5549 {
5550 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 23;
5551
5552 return ordinary(value, offset, NullUint32());
5553 }
5554
5557 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5558 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5559 static BlockLength blockLength(SchemaVersion version)
5560 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5561 {
5562 return
5563 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5564 minimalBlockLength(version);
5565 }
5566
5569 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5570 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5571 static
5572 BlockLength
5573 minimalBlockLength(
5574 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
5575 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5576 {
5577 return
5578 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
5579 27;
5580 }
5581
5583 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
5584 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5585 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
5586 static const Char* className()
5587 {
5588 return "ContractStandingData.ContractEMMPropertiesEntry";
5589 }
5590 };
5591
5593 typedef
5594 SbeGroup<ContractEMMPropertiesEntry, GroupSizeEncoding, MessageSize>
5595 ContractEMMProperties;
5596
5598 ContractStandingData() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
5599
5601 ContractStandingData(
5602 const void* data,
5603 EncodedLength length)
5604 : SbeMessage(data, length)
5605 {
5606 checkCompatibility();
5607 }
5608
5610 explicit
5611 ContractStandingData(
5612 const SbeMessage& message)
5613 : SbeMessage(message)
5614 {
5615 assert(message.valid());
5616
5617 checkCompatibility();
5618 }
5619
5621 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5622 bool seqNum(Uint64& value) const
5623 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5624 {
5625 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
5626
5627 return ordinary(value, offset, NullUint64());
5628 }
5629
5631 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5632 bool rebroadcastIndicator(UnsignedChar& value) const
5633 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5634 {
5635 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
5636
5637 return ordinary(value, offset, NullUnsignedChar());
5638 }
5639
5641 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5642 bool symbolIndex(Uint32& value) const
5643 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5644 {
5645 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
5646
5647 return ordinary(value, offset, NullUint32());
5648 }
5649
5651 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5659
5661 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5662 bool partitionId(Uint16& value) const
5663 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5664 {
5665 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 14;
5666
5667 return ordinary(value, offset, NullUint16());
5668 }
5669
5671 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5672 bool contractEventDate(Uint16& value) const
5673 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5674 {
5675 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 16;
5676
5677 return ordinary(value, offset, NullUint16());
5678 }
5679
5681 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5689
5691 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5692 bool
5701
5703 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5712
5714 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5715 bool
5724
5726 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5734
5736 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5737 bool priceDecimals(UnsignedChar& value) const
5738 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5739 {
5740 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 82;
5741
5742 return ordinary(value, offset, NullUnsignedChar());
5743 }
5744
5746 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5747 bool quantityDecimals(UnsignedChar& value) const
5748 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5749 {
5750 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 83;
5751
5752 return ordinary(value, offset, NullUnsignedChar());
5753 }
5754
5756 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5757 bool amountDecimals(UnsignedChar& value) const
5758 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5759 {
5760 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 84;
5761
5762 return ordinary(value, offset, NullUnsignedChar());
5763 }
5764
5766 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5767 bool ratioDecimals(UnsignedChar& value) const
5768 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5769 {
5770 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 85;
5771
5772 return ordinary(value, offset, NullUnsignedChar());
5773 }
5774
5776 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5785
5787 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5796
5798 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5807
5809 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5818
5820 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5829
5831 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5840
5842 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5843 bool underlyingExpiry(Uint32& value) const
5844 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5845 {
5846 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 118;
5847
5848 return ordinary(value, offset, NullUint32());
5849 }
5850
5852 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5860
5862 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5863 bool settlementMethod(Char& value) const
5864 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5865 {
5866 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 124;
5867
5868 return ordinary(value, offset, NullChar());
5869 }
5870
5872 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5881
5883 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5884 bool strikePriceDecimalsRatio(UnsignedChar& value) const
5885 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5886 {
5887 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 128;
5888
5889 return ordinary(value, offset, NullUnsignedChar());
5890 }
5891
5893 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5901
5903 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5904 ContractTradingType::Enum
5912
5914 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5915 bool
5924
5926 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5927 bool
5936
5938 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5947
5949 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5950 bool settlementTickSize(Uint64& value) const
5951 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5952 {
5953 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 145;
5954
5955 return ordinary(value, offset, NullUint64());
5956 }
5957
5959 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5960 bool eDSPTickSize(Uint64& value) const
5961 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5962 {
5963 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 153;
5964
5965 return ordinary(value, offset, NullUint64());
5966 }
5967
5969 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5970 bool underlyingSymbolIndex(Uint32& value) const
5971 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5972 {
5973 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 161;
5974
5975 return ordinary(value, offset, NullUint32());
5976 }
5977
5979 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5980 bool
5989
5991 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
5992 bool referenceSpreadTableId(Uint16& value) const
5993 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
5994 {
5995 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 166;
5996
5997 return ordinary(value, offset, NullUint16());
5998 }
5999
6001 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6002 bool
6011
6013 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6014 bool tradingUnit(Uint64& value) const
6015 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6016 {
6017 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 169;
6018
6019 return ordinary(value, offset, NullUint64());
6020 }
6021
6023 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6024 bool
6033
6035 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6036 bool
6045
6047 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6048 bool
6057
6059 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6060 bool collarExpansionFactor(UnsignedChar& value) const
6061 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6062 {
6063 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 180;
6064
6065 return ordinary(value, offset, NullUnsignedChar());
6066 }
6067
6069 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6070 bool mIFIdIILiquidFlag(UnsignedChar& value) const
6071 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6072 {
6073 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 181;
6074
6075 return ordinary(value, offset, NullUnsignedChar());
6076 }
6077
6079 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6087
6089 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6090 bool lotMultiplier(Uint64& value) const
6091 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6092 {
6093 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 183;
6094 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR SchemaVersion since = 327;
6095
6096 return ordinary(value, offset, NullUint64(), since);
6097 }
6098
6100 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6101 ContractEMMProperties contractEMMProperties() const
6102 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6103 {
6104 return getGroup<ContractEMMProperties>(
6105 ContractEMMPropertiesAccess(),
6106 *this);
6107 }
6108
6110 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6111 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6112 static BlockLength minimalBlockLength(SchemaVersion version)
6113 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6114 {
6115 return
6116 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6117 (version >= 327)
6118 ? 191
6119 : 183;
6120 }
6121
6123 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6124 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6125 static BlockLength blockLength(SchemaVersion version)
6126 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6127 {
6128 return
6129 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6130 minimalBlockLength(version);
6131 }
6132
6134 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6135 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6136 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6137 static
6138 MessageSize
6146
6148 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6149 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6150 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6151 static const Char* className()
6152 {
6153 return "ContractStandingData";
6154 }
6155
6157 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6158 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6159 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6160 static StrRef fixType()
6161 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6162 {
6163 return constructStrRef("ContractStandingData");
6164 }
6165
6167 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6168 std::string toString() const;
6169
6170private:
6171 void checkLength(
6172 EncodedLength length, SchemaVersion version) const
6173 {
6174 const EncodedLength minimalRequiredLength =
6175 minimalBlockLength(version) +
6176 MessageHeader::Size +
6177 getMinimalVariableFieldsSize(version);
6178
6179 checkBinaryLength(
6180 *this, length, minimalRequiredLength);
6181 }
6182
6184 void checkVarLenFields() const
6185 {
6186 groups().
6187 checkTail<ContractEMMProperties>();
6188 }
6189
6190 void checkCompatibility() const
6191 {
6192 assert(TemplateId == templateId());
6193
6194 checkSchema<Schema>(schemaId(), version());
6195 checkLength(bufferSize(), version());
6196 checkVarLenFields();
6197 }
6198
6200 struct ContractEMMPropertiesAccess
6201 {
6202 ContractEMMProperties
6203 operator()(
6204 const ContractStandingData& obj) const
6205 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6206 {
6207 return obj.
6208 groups().
6209 head<ContractEMMProperties>();
6210 }
6211 };
6212};
6213
6215ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
6216OutrightStandingData
6217: SbeMessage
6218{
6220 typedef SchemaTraits Schema;
6221
6223 enum { TemplateId = 1014 };
6224
6227 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
6228 OutrightRepEntry : SbeGroupEntry
6229 <
6230 GroupSizeEncoding::BlockLength
6231 >
6232 {
6234 typedef
6235 SbeGroupEntry
6236 <
6237 GroupSizeEncoding::BlockLength
6238 >
6239 Base;
6240
6243 OutrightRepEntry(
6244 const void* data,
6245 EncodedLength length,
6246 SchemaVersion version)
6247 : Base(data, numericCast<Base::BlockLength>(length), version)
6248 {
6249 assert(version >= Schema::MinimalVersion);
6250 assert(length >= minimalBlockLength(version));
6251 }
6252
6254 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6262
6265 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6266 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6267 static BlockLength blockLength(SchemaVersion version)
6268 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6269 {
6270 return
6271 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6272 minimalBlockLength(version);
6273 }
6274
6277 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6278 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6279 static
6280 BlockLength
6281 minimalBlockLength(
6282 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6283 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6284 {
6285 return
6286 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6287 1;
6288 }
6289
6291 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6292 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6293 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6294 static const Char* className()
6295 {
6296 return "OutrightStandingData.OutrightRepEntry";
6297 }
6298 };
6299
6301 typedef
6302 SbeGroup<OutrightRepEntry, GroupSizeEncoding, MessageSize>
6303 OutrightRep;
6304
6306 OutrightStandingData() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
6307
6309 OutrightStandingData(
6310 const void* data,
6311 EncodedLength length)
6312 : SbeMessage(data, length)
6313 {
6314 checkCompatibility();
6315 }
6316
6318 explicit
6319 OutrightStandingData(
6320 const SbeMessage& message)
6321 : SbeMessage(message)
6322 {
6323 assert(message.valid());
6324
6325 checkCompatibility();
6326 }
6327
6329 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6330 bool seqNum(Uint64& value) const
6331 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6332 {
6333 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
6334
6335 return ordinary(value, offset, NullUint64());
6336 }
6337
6339 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6340 bool rebroadcastIndicator(UnsignedChar& value) const
6341 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6342 {
6343 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
6344
6345 return ordinary(value, offset, NullUnsignedChar());
6346 }
6347
6349 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6350 bool symbolIndex(Uint32& value) const
6351 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6352 {
6353 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
6354
6355 return ordinary(value, offset, NullUint32());
6356 }
6357
6359 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6360 bool contractSymbolIndex(Uint32& value) const
6361 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6362 {
6363 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 13;
6364
6365 return ordinary(value, offset, NullUint32());
6366 }
6367
6369 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6370 bool instrumentEventDate(Uint16& value) const
6371 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6372 {
6373 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 17;
6374
6375 return ordinary(value, offset, NullUint16());
6376 }
6377
6379 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6388
6390 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6391 bool cFI(StrRef& value) const
6392 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6393 {
6394 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 31;
6395 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 6;
6396
6397 return fixedStr<length>(value, offset);
6398 }
6399
6401 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6410
6412 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6413 bool lotSize(Uint64& value) const
6414 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6415 {
6416 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 45;
6417
6418 return ordinary(value, offset, NullUint64());
6419 }
6420
6422 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6423 bool strikePrice(Int64& value) const
6424 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6425 {
6426 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 53;
6427
6428 return ordinary(value, offset, NullInt64());
6429 }
6430
6432 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6433 bool lastTradingDate(Uint16& value) const
6434 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6435 {
6436 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 61;
6437
6438 return ordinary(value, offset, NullUint16());
6439 }
6440
6442 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6443 bool daysToExpiry(Uint16& value) const
6444 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6445 {
6446 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 63;
6447
6448 return ordinary(value, offset, NullUint16());
6449 }
6450
6452 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6461
6463 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6464 bool
6473
6475 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6476 bool
6485
6487 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6496
6498 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6499 bool underlyingSymbolIndex(Uint32& value) const
6500 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6501 {
6502 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 103;
6503
6504 return ordinary(value, offset, NullUint32());
6505 }
6506
6508 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6509 bool tradingUnit(Uint64& value) const
6510 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6511 {
6512 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 107;
6513
6514 return ordinary(value, offset, NullUint64());
6515 }
6516
6518 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6519 bool lotMultiplier(Uint64& value) const
6520 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6521 {
6522 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 115;
6523 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR SchemaVersion since = 327;
6524
6525 return ordinary(value, offset, NullUint64(), since);
6526 }
6527
6529 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6530 bool expirationDate(Uint16& value) const
6531 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6532 {
6533 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 123;
6534 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR SchemaVersion since = 327;
6535
6536 return ordinary(value, offset, NullUint16(), since);
6537 }
6538
6540 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6541 OutrightRep outrightRep() const
6542 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6543 {
6544 return getGroup<OutrightRep>(
6545 OutrightRepAccess(),
6546 *this);
6547 }
6548
6550 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6551 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6552 static BlockLength minimalBlockLength(SchemaVersion version)
6553 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6554 {
6555 return
6556 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6557 (version >= 327)
6558 ? 125
6559 : 115;
6560 }
6561
6563 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6564 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6565 static BlockLength blockLength(SchemaVersion version)
6566 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6567 {
6568 return
6569 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6570 minimalBlockLength(version);
6571 }
6572
6574 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6575 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6576 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6577 static
6578 MessageSize
6579 getMinimalVariableFieldsSize(
6580 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6581 {
6582 return
6583 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6584 static_cast<MessageSize>(OutrightRep::EmptySize);
6585 }
6586
6588 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6589 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6590 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6591 static const Char* className()
6592 {
6593 return "OutrightStandingData";
6594 }
6595
6597 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6598 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6599 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6600 static StrRef fixType()
6601 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6602 {
6603 return constructStrRef("OutrightStandingData");
6604 }
6605
6607 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6608 std::string toString() const;
6609
6610private:
6611 void checkLength(
6612 EncodedLength length, SchemaVersion version) const
6613 {
6614 const EncodedLength minimalRequiredLength =
6615 minimalBlockLength(version) +
6616 MessageHeader::Size +
6617 getMinimalVariableFieldsSize(version);
6618
6619 checkBinaryLength(
6620 *this, length, minimalRequiredLength);
6621 }
6622
6624 void checkVarLenFields() const
6625 {
6626 groups().
6627 checkTail<OutrightRep>();
6628 }
6629
6630 void checkCompatibility() const
6631 {
6632 assert(TemplateId == templateId());
6633
6634 checkSchema<Schema>(schemaId(), version());
6635 checkLength(bufferSize(), version());
6636 checkVarLenFields();
6637 }
6638
6640 struct OutrightRepAccess
6641 {
6642 OutrightRep
6643 operator()(
6644 const OutrightStandingData& obj) const
6645 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6646 {
6647 return obj.
6648 groups().
6649 head<OutrightRep>();
6650 }
6651 };
6652};
6653
6655ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
6656LongOrderUpdate
6657: SbeMessage
6658{
6660 typedef SchemaTraits Schema;
6661
6663 enum { TemplateId = 1015 };
6664
6667 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
6668 OrdersEntry : SbeGroupEntry
6669 <
6670 GroupSizeEncoding::BlockLength
6671 >
6672 {
6674 typedef
6675 SbeGroupEntry
6676 <
6677 GroupSizeEncoding::BlockLength
6678 >
6679 Base;
6680
6683 OrdersEntry(
6684 const void* data,
6685 EncodedLength length,
6686 SchemaVersion version)
6687 : Base(data, numericCast<Base::BlockLength>(length), version)
6688 {
6689 assert(version >= Schema::MinimalVersion);
6690 assert(length >= minimalBlockLength(version));
6691 }
6692
6694 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6695 bool symbolIndex(Uint32& value) const
6696 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6697 {
6698 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
6699
6700 return ordinary(value, offset, NullUint32());
6701 }
6702
6704 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6705 MarketDataActionType::Enum
6713
6715 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6716 bool orderPriority(Uint64& value) const
6717 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6718 {
6719 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 5;
6720
6721 return ordinary(value, offset, NullUint64());
6722 }
6723
6725 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6726 bool previousPriority(Uint64& value) const
6727 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6728 {
6729 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 13;
6730
6731 return ordinary(value, offset, NullUint64());
6732 }
6733
6735 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6736 bool orderType(OrderType::Enum& value) const
6737 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6738 {
6739 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 21;
6740
6741 return enumeration<OrderType>(value, offset, NullUInt8());
6742 }
6743
6745 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6746 bool orderPx(Int64& value) const
6747 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6748 {
6749 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 22;
6750
6751 return ordinary(value, offset, NullInt64());
6752 }
6753
6755 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6756 bool orderSide(OrderSide::Enum& value) const
6757 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6758 {
6759 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 30;
6760
6761 return enumeration<OrderSide>(value, offset, NullUInt8());
6762 }
6763
6765 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6766 bool orderQuantity(Uint64& value) const
6767 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6768 {
6769 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 31;
6770
6771 return ordinary(value, offset, NullUint64());
6772 }
6773
6775 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6776 bool pegOffset(Int8& value) const
6777 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6778 {
6779 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 39;
6780
6781 return ordinary(value, offset, NullInt8());
6782 }
6783
6785 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6794
6796 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6804
6807 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6808 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6809 static BlockLength blockLength(SchemaVersion version)
6810 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6811 {
6812 return
6813 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6814 minimalBlockLength(version);
6815 }
6816
6819 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6820 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6821 static
6822 BlockLength
6823 minimalBlockLength(
6824 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6825 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6826 {
6827 return
6828 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6829 49;
6830 }
6831
6833 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6834 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6835 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6836 static const Char* className()
6837 {
6838 return "LongOrderUpdate.OrdersEntry";
6839 }
6840 };
6841
6843 typedef
6844 SbeGroup<OrdersEntry, GroupSizeEncoding, MessageSize>
6845 Orders;
6846
6848 LongOrderUpdate() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
6849
6851 LongOrderUpdate(
6852 const void* data,
6853 EncodedLength length)
6854 : SbeMessage(data, length)
6855 {
6856 checkCompatibility();
6857 }
6858
6860 explicit
6861 LongOrderUpdate(
6862 const SbeMessage& message)
6863 : SbeMessage(message)
6864 {
6865 assert(message.valid());
6866
6867 checkCompatibility();
6868 }
6869
6871 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6872 bool seqNum(Uint64& value) const
6873 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6874 {
6875 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
6876
6877 return ordinary(value, offset, NullUint64());
6878 }
6879
6881 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6882 bool rebroadcastIndicator(UnsignedChar& value) const
6883 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6884 {
6885 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
6886
6887 return ordinary(value, offset, NullUnsignedChar());
6888 }
6889
6891 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6899
6901 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6902 bool eventTime(Uint64& value) const
6903 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6904 {
6905 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
6906
6907 return ordinary(value, offset, NullUint64());
6908 }
6909
6911 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6912 Orders orders() const
6913 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6914 {
6915 return getGroup<Orders>(OrdersAccess(), *this);
6916 }
6917
6919 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6920 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6921 static
6922 BlockLength
6923 minimalBlockLength(
6924 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6925 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6926 {
6927 return
6928 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6929 18;
6930 }
6931
6933 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6934 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6935 static BlockLength blockLength(SchemaVersion version)
6936 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6937 {
6938 return
6939 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6940 minimalBlockLength(version);
6941 }
6942
6944 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6945 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6946 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6947 static
6948 MessageSize
6949 getMinimalVariableFieldsSize(
6950 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
6951 {
6952 return
6953 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
6954 static_cast<MessageSize>(Orders::EmptySize);
6955 }
6956
6958 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6959 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6960 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6961 static const Char* className()
6962 {
6963 return "LongOrderUpdate";
6964 }
6965
6967 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
6968 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6969 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
6970 static StrRef fixType()
6971 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
6972 {
6973 return constructStrRef("LongOrderUpdate");
6974 }
6975
6977 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
6978 std::string toString() const;
6979
6980private:
6981 void checkLength(
6982 EncodedLength length, SchemaVersion version) const
6983 {
6984 const EncodedLength minimalRequiredLength =
6985 minimalBlockLength(version) +
6986 MessageHeader::Size +
6987 getMinimalVariableFieldsSize(version);
6988
6989 checkBinaryLength(
6990 *this, length, minimalRequiredLength);
6991 }
6992
6994 void checkVarLenFields() const
6995 {
6996 groups().
6997 checkTail<Orders>();
6998 }
6999
7000 void checkCompatibility() const
7001 {
7002 assert(TemplateId == templateId());
7003
7004 checkSchema<Schema>(schemaId(), version());
7005 checkLength(bufferSize(), version());
7006 checkVarLenFields();
7007 }
7008
7010 struct OrdersAccess
7011 {
7012 Orders
7013 operator()(
7014 const LongOrderUpdate& obj) const
7015 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7016 {
7017 return obj.
7018 groups().
7019 head<Orders>();
7020 }
7021 };
7022};
7023
7025ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7026LisPackageStructure
7027: SbeMessage
7028{
7030 typedef SchemaTraits Schema;
7031
7033 enum { TemplateId = 1016 };
7034
7037 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7038 PackageComponentsEntry : SbeGroupEntry
7039 <
7040 GroupSizeEncoding::BlockLength
7041 >
7042 {
7044 typedef
7045 SbeGroupEntry
7046 <
7047 GroupSizeEncoding::BlockLength
7048 >
7049 Base;
7050
7053 PackageComponentsEntry(
7054 const void* data,
7055 EncodedLength length,
7056 SchemaVersion version)
7057 : Base(data, numericCast<Base::BlockLength>(length), version)
7058 {
7059 assert(version >= Schema::MinimalVersion);
7060 assert(length >= minimalBlockLength(version));
7061 }
7062
7064 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7065 bool legSymbolIndex(Uint32& value) const
7066 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7067 {
7068 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
7069
7070 return ordinary(value, offset, NullUint32());
7071 }
7072
7074 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7075 bool legRatio(Uint32& value) const
7076 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7077 {
7078 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 4;
7079
7080 return ordinary(value, offset, NullUint32());
7081 }
7082
7084 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7085 bool legLastPx(Int64& value) const
7086 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7087 {
7088 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
7089
7090 return ordinary(value, offset, NullInt64());
7091 }
7092
7094 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7095 bool legLastQty(Uint64& value) const
7096 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7097 {
7098 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 16;
7099
7100 return ordinary(value, offset, NullUint64());
7101 }
7102
7105 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7106 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7107 static BlockLength blockLength(SchemaVersion version)
7108 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7109 {
7110 return
7111 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7112 minimalBlockLength(version);
7113 }
7114
7117 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7118 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7119 static
7120 BlockLength
7121 minimalBlockLength(
7122 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7123 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7124 {
7125 return
7126 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7127 24;
7128 }
7129
7131 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7132 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7133 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7134 static const Char* className()
7135 {
7136 return "LisPackageStructure.PackageComponentsEntry";
7137 }
7138 };
7139
7141 typedef
7142 SbeGroup<PackageComponentsEntry, GroupSizeEncoding, MessageSize>
7143 PackageComponents;
7144
7146 LisPackageStructure() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
7147
7149 LisPackageStructure(
7150 const void* data,
7151 EncodedLength length)
7152 : SbeMessage(data, length)
7153 {
7154 checkCompatibility();
7155 }
7156
7158 explicit
7159 LisPackageStructure(
7160 const SbeMessage& message)
7161 : SbeMessage(message)
7162 {
7163 assert(message.valid());
7164
7165 checkCompatibility();
7166 }
7167
7169 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7170 bool seqNum(Uint64& value) const
7171 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7172 {
7173 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
7174
7175 return ordinary(value, offset, NullUint64());
7176 }
7177
7179 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7180 bool rebroadcastIndicator(UnsignedChar& value) const
7181 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7182 {
7183 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
7184
7185 return ordinary(value, offset, NullUnsignedChar());
7186 }
7187
7189 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7197
7199 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7200 bool eventTime(Uint64& value) const
7201 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7202 {
7203 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
7204
7205 return ordinary(value, offset, NullUint64());
7206 }
7207
7209 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7210 bool contractSymbolIndex(Uint32& value) const
7211 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7212 {
7213 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 18;
7214
7215 return ordinary(value, offset, NullUint32());
7216 }
7217
7219 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7228
7230 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7238
7240 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7241 PackageComponents packageComponents() const
7242 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7243 {
7244 return getGroup<PackageComponents>(
7245 PackageComponentsAccess(),
7246 *this);
7247 }
7248
7250 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7251 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7252 static
7253 BlockLength
7254 minimalBlockLength(
7255 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7256 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7257 {
7258 return
7259 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7260 75;
7261 }
7262
7264 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7265 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7266 static BlockLength blockLength(SchemaVersion version)
7267 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7268 {
7269 return
7270 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7271 minimalBlockLength(version);
7272 }
7273
7275 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7276 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7277 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7278 static
7279 MessageSize
7280 getMinimalVariableFieldsSize(
7281 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7282 {
7283 return
7284 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7285 static_cast<MessageSize>(PackageComponents::EmptySize);
7286 }
7287
7289 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7290 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7291 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7292 static const Char* className()
7293 {
7294 return "LisPackageStructure";
7295 }
7296
7298 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7299 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7300 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7301 static StrRef fixType()
7302 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7303 {
7304 return constructStrRef("LISPackageStructure");
7305 }
7306
7308 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7309 std::string toString() const;
7310
7311private:
7312 void checkLength(
7313 EncodedLength length, SchemaVersion version) const
7314 {
7315 const EncodedLength minimalRequiredLength =
7316 minimalBlockLength(version) +
7317 MessageHeader::Size +
7318 getMinimalVariableFieldsSize(version);
7319
7320 checkBinaryLength(
7321 *this, length, minimalRequiredLength);
7322 }
7323
7325 void checkVarLenFields() const
7326 {
7327 groups().
7328 checkTail<PackageComponents>();
7329 }
7330
7331 void checkCompatibility() const
7332 {
7333 assert(TemplateId == templateId());
7334
7335 checkSchema<Schema>(schemaId(), version());
7336 checkLength(bufferSize(), version());
7337 checkVarLenFields();
7338 }
7339
7341 struct PackageComponentsAccess
7342 {
7343 PackageComponents
7344 operator()(
7345 const LisPackageStructure& obj) const
7346 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7347 {
7348 return obj.
7349 groups().
7350 head<PackageComponents>();
7351 }
7352 };
7353};
7354
7356ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7357ApaQuotes
7358: SbeMessage
7359{
7361 typedef SchemaTraits Schema;
7362
7364 enum { TemplateId = 1026 };
7365
7367 ApaQuotes() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
7368
7370 ApaQuotes(
7371 const void* data,
7372 EncodedLength length)
7373 : SbeMessage(data, length)
7374 {
7375 checkCompatibility();
7376 }
7377
7379 explicit
7380 ApaQuotes(
7381 const SbeMessage& message)
7382 : SbeMessage(message)
7383 {
7384 assert(message.valid());
7385
7386 checkCompatibility();
7387 }
7388
7390 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7391 bool seqNum(Uint64& value) const
7392 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7393 {
7394 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
7395
7396 return ordinary(value, offset, NullUint64());
7397 }
7398
7400 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7401 bool rebroadcastIndicator(UnsignedChar& value) const
7402 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7403 {
7404 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
7405
7406 return ordinary(value, offset, NullUnsignedChar());
7407 }
7408
7410 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7419
7421 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7430
7432 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7441
7443 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7452
7454 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7463
7465 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7466 bool eventTime(Uint64& value) const
7467 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7468 {
7469 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 52;
7470
7471 return ordinary(value, offset, NullUint64());
7472 }
7473
7475 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7483
7485 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7494
7496 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7505
7507 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7508 bool aPAOrigin(StrRef& value) const
7509 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7510 {
7511 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 101;
7512 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 4;
7513
7514 return fixedStr<length>(value, offset);
7515 }
7516
7518 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7519 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7520 static
7521 BlockLength
7522 minimalBlockLength(
7523 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7524 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7525 {
7526 return
7527 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7528 105;
7529 }
7530
7532 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7533 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7534 static BlockLength blockLength(SchemaVersion version)
7535 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7536 {
7537 return
7538 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7539 minimalBlockLength(version);
7540 }
7541
7543 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7544 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7545 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7546 static
7547 MessageSize
7548 getMinimalVariableFieldsSize(
7549 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7550 {
7551 return
7552 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7553 0;
7554 }
7555
7557 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7558 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7559 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7560 static const Char* className()
7561 {
7562 return "ApaQuotes";
7563 }
7564
7566 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7567 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7568 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7569 static StrRef fixType()
7570 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7571 {
7572 return constructStrRef("APAQuotes");
7573 }
7574
7576 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7577 std::string toString() const;
7578
7579private:
7580 void checkLength(
7581 EncodedLength length, SchemaVersion version) const
7582 {
7583 const EncodedLength minimalRequiredLength =
7584 minimalBlockLength(version) +
7585 MessageHeader::Size +
7586 getMinimalVariableFieldsSize(version);
7587
7588 checkBinaryLength(
7589 *this, length, minimalRequiredLength);
7590 }
7591
7592 void checkCompatibility() const
7593 {
7594 assert(TemplateId == templateId());
7595
7596 checkSchema<Schema>(schemaId(), version());
7597 checkLength(bufferSize(), version());
7598 }
7599};
7600
7602ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7603ApaStandingData
7604: SbeMessage
7605{
7607 typedef SchemaTraits Schema;
7608
7610 enum { TemplateId = 1027 };
7611
7613 ApaStandingData() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
7614
7616 ApaStandingData(
7617 const void* data,
7618 EncodedLength length)
7619 : SbeMessage(data, length)
7620 {
7621 checkCompatibility();
7622 }
7623
7625 explicit
7626 ApaStandingData(
7627 const SbeMessage& message)
7628 : SbeMessage(message)
7629 {
7630 assert(message.valid());
7631
7632 checkCompatibility();
7633 }
7634
7636 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7637 bool seqNum(Uint64& value) const
7638 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7639 {
7640 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
7641
7642 return ordinary(value, offset, NullUint64());
7643 }
7644
7646 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7647 bool rebroadcastIndicator(UnsignedChar& value) const
7648 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7649 {
7650 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
7651
7652 return ordinary(value, offset, NullUnsignedChar());
7653 }
7654
7656 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7665
7667 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7676
7678 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7687
7689 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7690 bool cFI(StrRef& value) const
7691 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7692 {
7693 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 127;
7694 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 6;
7695
7696 return fixedStr<length>(value, offset);
7697 }
7698
7700 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7709
7711 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7720
7722 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7723 bool priceMultiplier(Uint32& value) const
7724 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7725 {
7726 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 139;
7727
7728 return ordinary(value, offset, NullUint32());
7729 }
7730
7732 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7733 bool priceMultiplierDecimals(UnsignedChar& value) const
7734 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7735 {
7736 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 143;
7737
7738 return ordinary(value, offset, NullUnsignedChar());
7739 }
7740
7742 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7751
7753 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7762
7764 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7773
7775 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7776 bool optionType(OptionType::Enum& value) const
7777 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7778 {
7779 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 189;
7780
7781 return enumeration<OptionType>(value, offset, NullUInt8());
7782 }
7783
7785 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7786 bool strikePrice(Int64& value) const
7787 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7788 {
7789 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 190;
7790
7791 return ordinary(value, offset, NullInt64());
7792 }
7793
7795 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7796 bool strikePriceDecimals(UnsignedChar& value) const
7797 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7798 {
7799 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 198;
7800
7801 return ordinary(value, offset, NullUnsignedChar());
7802 }
7803
7805 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7806 bool
7807 exerStyle(
7808 ExerciseStyle::Enum& value) const
7809 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7810 {
7811 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 199;
7812
7813 return enumeration<ExerciseStyle>(value, offset, NullUInt8());
7814 }
7815
7817 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7826
7828 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7829 bool expiryDate(StrRef& value) const
7830 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7831 {
7832 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 208;
7833 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 8;
7834
7835 return fixedStr<length>(value, offset);
7836 }
7837
7839 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7840 bool settlementMethod(Char& value) const
7841 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7842 {
7843 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 216;
7844
7845 return ordinary(value, offset, NullChar());
7846 }
7847
7849 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7850 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7851 static
7852 BlockLength
7853 minimalBlockLength(
7854 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7855 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7856 {
7857 return
7858 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7859 217;
7860 }
7861
7863 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7864 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7865 static BlockLength blockLength(SchemaVersion version)
7866 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7867 {
7868 return
7869 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7870 minimalBlockLength(version);
7871 }
7872
7874 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7875 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7876 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7877 static
7878 MessageSize
7879 getMinimalVariableFieldsSize(
7880 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
7881 {
7882 return
7883 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
7884 0;
7885 }
7886
7888 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7889 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7890 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7891 static const Char* className()
7892 {
7893 return "ApaStandingData";
7894 }
7895
7897 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
7898 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7899 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
7900 static StrRef fixType()
7901 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7902 {
7903 return constructStrRef("APAStandingData");
7904 }
7905
7907 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7908 std::string toString() const;
7909
7910private:
7911 void checkLength(
7912 EncodedLength length, SchemaVersion version) const
7913 {
7914 const EncodedLength minimalRequiredLength =
7915 minimalBlockLength(version) +
7916 MessageHeader::Size +
7917 getMinimalVariableFieldsSize(version);
7918
7919 checkBinaryLength(
7920 *this, length, minimalRequiredLength);
7921 }
7922
7923 void checkCompatibility() const
7924 {
7925 assert(TemplateId == templateId());
7926
7927 checkSchema<Schema>(schemaId(), version());
7928 checkLength(bufferSize(), version());
7929 }
7930};
7931
7933ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
7934ApaFullTradeInformation
7935: SbeMessage
7936{
7938 typedef SchemaTraits Schema;
7939
7941 enum { TemplateId = 1028 };
7942
7944 ApaFullTradeInformation() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
7945
7947 ApaFullTradeInformation(
7948 const void* data,
7949 EncodedLength length)
7950 : SbeMessage(data, length)
7951 {
7952 checkCompatibility();
7953 }
7954
7956 explicit
7957 ApaFullTradeInformation(
7958 const SbeMessage& message)
7959 : SbeMessage(message)
7960 {
7961 assert(message.valid());
7962
7963 checkCompatibility();
7964 }
7965
7967 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7968 bool seqNum(Uint64& value) const
7969 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7970 {
7971 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
7972
7973 return ordinary(value, offset, NullUint64());
7974 }
7975
7977 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7978 bool rebroadcastIndicator(UnsignedChar& value) const
7979 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
7980 {
7981 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
7982
7983 return ordinary(value, offset, NullUnsignedChar());
7984 }
7985
7987 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7995
7997 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
7998 bool eventTime(Uint64& value) const
7999 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8000 {
8001 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 10;
8002
8003 return ordinary(value, offset, NullUint64());
8004 }
8005
8007 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8016
8018 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8027
8029 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8037
8039 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8048
8050 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8059
8061 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8070
8072 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8073 bool mifidPrice(StrRef& value) const
8074 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8075 {
8076 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 141;
8077 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 20;
8078
8079 return fixedStr<length>(value, offset);
8080 }
8081
8083 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8092
8094 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8103
8105 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8114
8116 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8125
8127 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8136
8138 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8147
8149 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8158
8160 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8169
8171 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8172 bool
8181
8183 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8184 bool
8193
8195 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8196 bool
8205
8207 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8208 bool
8217
8219 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8220 bool
8229
8231 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8232 bool
8241
8243 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8244 bool
8253
8255 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8256 bool
8265
8267 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8268 bool
8277
8279 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8280 bool
8289
8291 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8292 bool
8301
8303 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8304 bool
8313
8315 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8316 bool
8325
8327 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8328 bool
8337
8339 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8348
8350 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8351 bool originalReportTimestamp(Uint64& value) const
8352 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8353 {
8354 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 305;
8355
8356 return ordinary(value, offset, NullUint64());
8357 }
8358
8360 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8361 bool priceMultiplier(Uint32& value) const
8362 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8363 {
8364 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 313;
8365
8366 return ordinary(value, offset, NullUint32());
8367 }
8368
8370 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8371 bool priceMultiplierDecimals(UnsignedChar& value) const
8372 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8373 {
8374 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 317;
8375
8376 return ordinary(value, offset, NullUnsignedChar());
8377 }
8378
8380 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8389
8391 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8400
8402 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8411
8413 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8414 bool aPAOrigin(StrRef& value) const
8415 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8416 {
8417 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 385;
8418 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 4;
8419
8420 return fixedStr<length>(value, offset);
8421 }
8422
8424 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8434
8436 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8437 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
8438 static BlockLength minimalBlockLength(SchemaVersion version)
8439 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8440 {
8441 return
8442 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8443 (version >= 316)
8444 ? 405
8445 : 389;
8446 }
8447
8449 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8450 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
8451 static BlockLength blockLength(SchemaVersion version)
8452 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8453 {
8454 return
8455 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8456 minimalBlockLength(version);
8457 }
8458
8460 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8461 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8462 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
8463 static
8464 MessageSize
8465 getMinimalVariableFieldsSize(
8466 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
8467 {
8468 return
8469 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8470 0;
8471 }
8472
8474 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8475 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8476 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
8477 static const Char* className()
8478 {
8479 return "ApaFullTradeInformation";
8480 }
8481
8483 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8484 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8485 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
8486 static StrRef fixType()
8487 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8488 {
8489 return constructStrRef(
8490 "APAFullTradeInformation");
8491 }
8492
8494 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8495 std::string toString() const;
8496
8497private:
8498 void checkLength(
8499 EncodedLength length, SchemaVersion version) const
8500 {
8501 const EncodedLength minimalRequiredLength =
8502 minimalBlockLength(version) +
8503 MessageHeader::Size +
8504 getMinimalVariableFieldsSize(version);
8505
8506 checkBinaryLength(
8507 *this, length, minimalRequiredLength);
8508 }
8509
8510 void checkCompatibility() const
8511 {
8512 assert(TemplateId == templateId());
8513
8514 checkSchema<Schema>(schemaId(), version());
8515 checkLength(bufferSize(), version());
8516 }
8517};
8518
8520ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
8521BfInstrumentReference
8522: SbeMessage
8523{
8525 typedef SchemaTraits Schema;
8526
8528 enum { TemplateId = 1201 };
8529
8532 ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
8533 InterestPaymentDateRepEntry : SbeGroupEntry
8534 <
8535 GroupSizeEncoding::BlockLength
8536 >
8537 {
8539 typedef
8540 SbeGroupEntry
8541 <
8542 GroupSizeEncoding::BlockLength
8543 >
8544 Base;
8545
8548 InterestPaymentDateRepEntry(
8549 const void* data,
8550 EncodedLength length,
8551 SchemaVersion version)
8552 : Base(data, numericCast<Base::BlockLength>(length), version)
8553 {
8554 assert(version >= Schema::MinimalVersion);
8555 assert(length >= minimalBlockLength(version));
8556 }
8557
8559 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8560 bool interestPaymentDate(Uint16& value) const
8561 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8562 {
8563 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
8564
8565 return ordinary(value, offset, NullUint16());
8566 }
8567
8570 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8571 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
8572 static BlockLength blockLength(SchemaVersion version)
8573 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8574 {
8575 return
8576 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8577 minimalBlockLength(version);
8578 }
8579
8582 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8583 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
8584 static
8585 BlockLength
8586 minimalBlockLength(
8587 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
8588 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8589 {
8590 return
8591 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
8592 2;
8593 }
8594
8596 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
8597 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8598 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
8599 static const Char* className()
8600 {
8601 return "BfInstrumentReference.InterestPaymentDateRepEntry";
8602 }
8603 };
8604
8606 typedef
8607 SbeGroup<InterestPaymentDateRepEntry, GroupSizeEncoding, MessageSize>
8608 InterestPaymentDateRep;
8609
8611 BfInstrumentReference() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
8612
8614 BfInstrumentReference(
8615 const void* data,
8616 EncodedLength length)
8617 : SbeMessage(data, length)
8618 {
8619 checkCompatibility();
8620 }
8621
8623 explicit
8624 BfInstrumentReference(
8625 const SbeMessage& message)
8626 : SbeMessage(message)
8627 {
8628 assert(message.valid());
8629
8630 checkCompatibility();
8631 }
8632
8634 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8635 bool seqNum(Uint64& value) const
8636 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8637 {
8638 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
8639
8640 return ordinary(value, offset, NullUint64());
8641 }
8642
8644 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8645 bool rebroadcastIndicator(UnsignedChar& value) const
8646 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8647 {
8648 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
8649
8650 return ordinary(value, offset, NullUnsignedChar());
8651 }
8652
8654 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8655 bool symbolIndex(Uint32& value) const
8656 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8657 {
8658 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
8659
8660 return ordinary(value, offset, NullUint32());
8661 }
8662
8664 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8672
8674 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8675 bool iSINCode(StrRef& value) const
8676 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8677 {
8678 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 14;
8679 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 12;
8680
8681 return fixedStr<length>(value, offset);
8682 }
8683
8685 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8694
8696 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8705
8707 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8716
8718 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8719 bool currency(StrRef& value) const
8720 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8721 {
8722 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 533;
8723 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 3;
8724
8725 return fixedStr<length>(value, offset);
8726 }
8727
8729 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8730 bool dateOfInitialListing(Uint16& value) const
8731 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8732 {
8733 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 536;
8734
8735 return ordinary(value, offset, NullUint16());
8736 }
8737
8739 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8740 bool shareAmountInIssue(Int64& value) const
8741 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8742 {
8743 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 538;
8744
8745 return ordinary(value, offset, NullInt64());
8746 }
8747
8749 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8750 bool
8759
8761 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8762 bool lastNAVPrice(Int64& value) const
8763 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8764 {
8765 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 547;
8766
8767 return ordinary(value, offset, NullInt64());
8768 }
8769
8771 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8772 bool
8781
8783 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8784 bool coupon(Int64& value) const
8785 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8786 {
8787 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 556;
8788
8789 return ordinary(value, offset, NullInt64());
8790 }
8791
8793 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8802
8804 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8805 bool closingPrice(Int64& value) const
8806 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8807 {
8808 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 572;
8809
8810 return ordinary(value, offset, NullInt64());
8811 }
8812
8814 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8815 bool mIC(StrRef& value) const
8816 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8817 {
8818 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 580;
8819 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 4;
8820
8821 return fixedStr<length>(value, offset);
8822 }
8823
8825 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8826 bool grossDividendPayablePerUnit(Int64& value) const
8827 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8828 {
8829 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 584;
8830
8831 return ordinary(value, offset, NullInt64());
8832 }
8833
8835 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8844
8846 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8847 bool dividendRecordDate(Uint16& value) const
8848 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8849 {
8850 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 595;
8851
8852 return ordinary(value, offset, NullUint16());
8853 }
8854
8856 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8857 bool dividendRate(Uint64& value) const
8858 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8859 {
8860 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 597;
8861
8862 return ordinary(value, offset, NullUint64());
8863 }
8864
8866 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8867 bool exDividendDate(Uint16& value) const
8868 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8869 {
8870 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 605;
8871
8872 return ordinary(value, offset, NullUint16());
8873 }
8874
8876 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8877 bool dividendPaymentDate(Uint16& value) const
8878 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8879 {
8880 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 607;
8881
8882 return ordinary(value, offset, NullUint16());
8883 }
8884
8886 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8887 bool
8896
8898 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8907
8909 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8910 bool grossDividendInEuros(Int64& value) const
8911 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8912 {
8913 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 618;
8914
8915 return ordinary(value, offset, NullInt64());
8916 }
8917
8919 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8920 bool issueDate(Uint16& value) const
8921 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8922 {
8923 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 626;
8924
8925 return ordinary(value, offset, NullUint16());
8926 }
8927
8929 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8938
8940 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8941 bool cFI(StrRef& value) const
8942 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8943 {
8944 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 631;
8945 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength length = 6;
8946
8947 return fixedStr<length>(value, offset);
8948 }
8949
8951 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8952 bool
8961
8963 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8964 bool minimumAmount(Int64& value) const
8965 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
8966 {
8967 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 638;
8968
8969 return ordinary(value, offset, NullInt64());
8970 }
8971
8973 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8981
8983 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
8984 bool
8993
8995 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9004
9006 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9007 bool priceIndexLevelDecimals(UnsignedChar& value) const
9008 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9009 {
9010 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 652;
9011
9012 return ordinary(value, offset, NullUnsignedChar());
9013 }
9014
9016 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9017 bool quantityDecimals(UnsignedChar& value) const
9018 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9019 {
9020 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 653;
9021
9022 return ordinary(value, offset, NullUnsignedChar());
9023 }
9024
9026 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9027 bool amountDecimals(UnsignedChar& value) const
9028 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9029 {
9030 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 654;
9031
9032 return ordinary(value, offset, NullUnsignedChar());
9033 }
9034
9036 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9037 bool ratioMultiplierDecimals(UnsignedChar& value) const
9038 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9039 {
9040 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 655;
9041
9042 return ordinary(value, offset, NullUnsignedChar());
9043 }
9044
9046 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9047 InterestPaymentDateRep interestPaymentDateRep() const
9048 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9049 {
9050 return getGroup<InterestPaymentDateRep>(
9051 InterestPaymentDateRepAccess(),
9052 *this);
9053 }
9054
9056 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9057 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9058 static
9059 BlockLength
9060 minimalBlockLength(
9061 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9062 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9063 {
9064 return
9065 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9066 656;
9067 }
9068
9070 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9071 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9072 static BlockLength blockLength(SchemaVersion version)
9073 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9074 {
9075 return
9076 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9077 minimalBlockLength(version);
9078 }
9079
9081 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9082 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9083 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9084 static
9085 MessageSize
9093
9095 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9096 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9097 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9098 static const Char* className()
9099 {
9100 return "BfInstrumentReference";
9101 }
9102
9104 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9105 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9106 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9107 static StrRef fixType()
9108 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9109 {
9110 return constructStrRef("BFInstrumentReference");
9111 }
9112
9114 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9115 std::string toString() const;
9116
9117private:
9118 void checkLength(
9119 EncodedLength length, SchemaVersion version) const
9120 {
9121 const EncodedLength minimalRequiredLength =
9122 minimalBlockLength(version) +
9123 MessageHeader::Size +
9124 getMinimalVariableFieldsSize(version);
9125
9126 checkBinaryLength(
9127 *this, length, minimalRequiredLength);
9128 }
9129
9131 void checkVarLenFields() const
9132 {
9133 groups().
9134 checkTail<InterestPaymentDateRep>();
9135 }
9136
9137 void checkCompatibility() const
9138 {
9139 assert(TemplateId == templateId());
9140
9141 checkSchema<Schema>(schemaId(), version());
9142 checkLength(bufferSize(), version());
9143 checkVarLenFields();
9144 }
9145
9147 struct InterestPaymentDateRepAccess
9148 {
9149 InterestPaymentDateRep
9150 operator()(
9151 const BfInstrumentReference& obj) const
9152 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9153 {
9154 return obj.
9155 groups().
9156 head<InterestPaymentDateRep>();
9157 }
9158 };
9159};
9160
9162ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
9163BfTrade
9164: SbeMessage
9165{
9167 typedef SchemaTraits Schema;
9168
9170 enum { TemplateId = 1202 };
9171
9173 BfTrade() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
9174
9176 BfTrade(
9177 const void* data,
9178 EncodedLength length)
9179 : SbeMessage(data, length)
9180 {
9181 checkCompatibility();
9182 }
9183
9185 explicit
9186 BfTrade(
9187 const SbeMessage& message)
9188 : SbeMessage(message)
9189 {
9190 assert(message.valid());
9191
9192 checkCompatibility();
9193 }
9194
9196 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9197 bool seqNum(Uint64& value) const
9198 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9199 {
9200 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
9201
9202 return ordinary(value, offset, NullUint64());
9203 }
9204
9206 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9207 bool rebroadcastIndicator(UnsignedChar& value) const
9208 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9209 {
9210 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
9211
9212 return ordinary(value, offset, NullUnsignedChar());
9213 }
9214
9216 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9217 bool symbolIndex(Uint32& value) const
9218 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9219 {
9220 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
9221
9222 return ordinary(value, offset, NullUint32());
9223 }
9224
9226 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9235
9237 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9238 bool eventTime(Uint64& value) const
9239 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9240 {
9241 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 65;
9242
9243 return ordinary(value, offset, NullUint64());
9244 }
9245
9247 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9248 bool bidOfferDateTime(Uint64& value) const
9249 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9250 {
9251 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 73;
9252
9253 return ordinary(value, offset, NullUint64());
9254 }
9255
9257 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9266
9268 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9269 bool price(Int64& value) const
9270 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9271 {
9272 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 85;
9273
9274 return ordinary(value, offset, NullInt64());
9275 }
9276
9278 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9279 bool bidPrice(Int64& value) const
9280 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9281 {
9282 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 93;
9283
9284 return ordinary(value, offset, NullInt64());
9285 }
9286
9288 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9289 bool offerPrice(Int64& value) const
9290 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9291 {
9292 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 101;
9293
9294 return ordinary(value, offset, NullInt64());
9295 }
9296
9298 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9299 bool quantity(Uint64& value) const
9300 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9301 {
9302 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 109;
9303
9304 return ordinary(value, offset, NullUint64());
9305 }
9306
9308 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9317
9319 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9328
9330 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9339
9341 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9342 bool
9351
9353 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9362
9364 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9373
9375 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9376 bool notionalAmountTraded(Int64& value) const
9377 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9378 {
9379 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 137;
9380
9381 return ordinary(value, offset, NullInt64());
9382 }
9383
9385 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9394
9396 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9397 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9398 static
9399 BlockLength
9400 minimalBlockLength(
9401 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9402 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9403 {
9404 return
9405 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9406 148;
9407 }
9408
9410 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9411 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9412 static BlockLength blockLength(SchemaVersion version)
9413 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9414 {
9415 return
9416 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9417 minimalBlockLength(version);
9418 }
9419
9421 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9422 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9423 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9424 static
9425 MessageSize
9426 getMinimalVariableFieldsSize(
9427 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9428 {
9429 return
9430 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9431 0;
9432 }
9433
9435 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9436 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9437 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9438 static const Char* className()
9439 {
9440 return "BfTrade";
9441 }
9442
9444 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9445 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9446 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9447 static StrRef fixType()
9448 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9449 {
9450 return constructStrRef("BFTrade");
9451 }
9452
9454 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9455 std::string toString() const;
9456
9457private:
9458 void checkLength(
9459 EncodedLength length, SchemaVersion version) const
9460 {
9461 const EncodedLength minimalRequiredLength =
9462 minimalBlockLength(version) +
9463 MessageHeader::Size +
9464 getMinimalVariableFieldsSize(version);
9465
9466 checkBinaryLength(
9467 *this, length, minimalRequiredLength);
9468 }
9469
9470 void checkCompatibility() const
9471 {
9472 assert(TemplateId == templateId());
9473
9474 checkSchema<Schema>(schemaId(), version());
9475 checkLength(bufferSize(), version());
9476 }
9477};
9478
9480ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
9481Bfnav
9482: SbeMessage
9483{
9485 typedef SchemaTraits Schema;
9486
9488 enum { TemplateId = 1203 };
9489
9491 Bfnav() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
9492
9494 Bfnav(
9495 const void* data,
9496 EncodedLength length)
9497 : SbeMessage(data, length)
9498 {
9499 checkCompatibility();
9500 }
9501
9503 explicit
9504 Bfnav(
9505 const SbeMessage& message)
9506 : SbeMessage(message)
9507 {
9508 assert(message.valid());
9509
9510 checkCompatibility();
9511 }
9512
9514 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9515 bool seqNum(Uint64& value) const
9516 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9517 {
9518 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
9519
9520 return ordinary(value, offset, NullUint64());
9521 }
9522
9524 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9525 bool rebroadcastIndicator(UnsignedChar& value) const
9526 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9527 {
9528 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
9529
9530 return ordinary(value, offset, NullUnsignedChar());
9531 }
9532
9534 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9535 bool symbolIndex(Uint32& value) const
9536 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9537 {
9538 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
9539
9540 return ordinary(value, offset, NullUint32());
9541 }
9542
9544 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9545 bool bidOfferDateTime(Uint64& value) const
9546 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9547 {
9548 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 13;
9549
9550 return ordinary(value, offset, NullUint64());
9551 }
9552
9554 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9563
9565 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9574
9576 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9577 bool nAVPrice(Int64& value) const
9578 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9579 {
9580 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 77;
9581
9582 return ordinary(value, offset, NullInt64());
9583 }
9584
9586 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9587 bool eventTime(Uint64& value) const
9588 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9589 {
9590 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 85;
9591
9592 return ordinary(value, offset, NullUint64());
9593 }
9594
9596 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9597 bool nAVBidPrice(Int64& value) const
9598 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9599 {
9600 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 93;
9601
9602 return ordinary(value, offset, NullInt64());
9603 }
9604
9606 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9607 bool nAVOfferPrice(Int64& value) const
9608 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9609 {
9610 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 101;
9611
9612 return ordinary(value, offset, NullInt64());
9613 }
9614
9616 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9617 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9618 static
9619 BlockLength
9620 minimalBlockLength(
9621 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9622 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9623 {
9624 return
9625 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9626 109;
9627 }
9628
9630 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9631 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9632 static BlockLength blockLength(SchemaVersion version)
9633 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9634 {
9635 return
9636 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9637 minimalBlockLength(version);
9638 }
9639
9641 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9642 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9643 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9644 static
9645 MessageSize
9646 getMinimalVariableFieldsSize(
9647 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9648 {
9649 return
9650 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9651 0;
9652 }
9653
9655 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9656 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9657 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9658 static const Char* className()
9659 {
9660 return "Bfnav";
9661 }
9662
9664 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9665 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9666 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9667 static StrRef fixType()
9668 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9669 {
9670 return constructStrRef("BFNAV");
9671 }
9672
9674 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9675 std::string toString() const;
9676
9677private:
9678 void checkLength(
9679 EncodedLength length, SchemaVersion version) const
9680 {
9681 const EncodedLength minimalRequiredLength =
9682 minimalBlockLength(version) +
9683 MessageHeader::Size +
9684 getMinimalVariableFieldsSize(version);
9685
9686 checkBinaryLength(
9687 *this, length, minimalRequiredLength);
9688 }
9689
9690 void checkCompatibility() const
9691 {
9692 assert(TemplateId == templateId());
9693
9694 checkSchema<Schema>(schemaId(), version());
9695 checkLength(bufferSize(), version());
9696 }
9697};
9698
9700ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
9701BfInstrumentSuspension
9702: SbeMessage
9703{
9705 typedef SchemaTraits Schema;
9706
9708 enum { TemplateId = 1204 };
9709
9711 BfInstrumentSuspension() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
9712
9714 BfInstrumentSuspension(
9715 const void* data,
9716 EncodedLength length)
9717 : SbeMessage(data, length)
9718 {
9719 checkCompatibility();
9720 }
9721
9723 explicit
9724 BfInstrumentSuspension(
9725 const SbeMessage& message)
9726 : SbeMessage(message)
9727 {
9728 assert(message.valid());
9729
9730 checkCompatibility();
9731 }
9732
9734 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9735 bool seqNum(Uint64& value) const
9736 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9737 {
9738 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
9739
9740 return ordinary(value, offset, NullUint64());
9741 }
9742
9744 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9745 bool rebroadcastIndicator(UnsignedChar& value) const
9746 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9747 {
9748 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
9749
9750 return ordinary(value, offset, NullUnsignedChar());
9751 }
9752
9754 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9755 bool symbolIndex(Uint32& value) const
9756 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9757 {
9758 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 9;
9759
9760 return ordinary(value, offset, NullUint32());
9761 }
9762
9764 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9765 bool eventTime(Uint64& value) const
9766 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9767 {
9768 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 13;
9769
9770 return ordinary(value, offset, NullUint64());
9771 }
9772
9774 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9775 bool
9784
9786 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9787 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9788 static
9789 BlockLength
9790 minimalBlockLength(
9791 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9792 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9793 {
9794 return
9795 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9796 22;
9797 }
9798
9800 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9801 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9802 static BlockLength blockLength(SchemaVersion version)
9803 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9804 {
9805 return
9806 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9807 minimalBlockLength(version);
9808 }
9809
9811 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9812 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9813 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9814 static
9815 MessageSize
9816 getMinimalVariableFieldsSize(
9817 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9818 {
9819 return
9820 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9821 0;
9822 }
9823
9825 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9826 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9827 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9828 static const Char* className()
9829 {
9830 return "BfInstrumentSuspension";
9831 }
9832
9834 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9835 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9836 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9837 static StrRef fixType()
9838 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9839 {
9840 return constructStrRef("BFInstrumentSuspension");
9841 }
9842
9844 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9845 std::string toString() const;
9846
9847private:
9848 void checkLength(
9849 EncodedLength length, SchemaVersion version) const
9850 {
9851 const EncodedLength minimalRequiredLength =
9852 minimalBlockLength(version) +
9853 MessageHeader::Size +
9854 getMinimalVariableFieldsSize(version);
9855
9856 checkBinaryLength(
9857 *this, length, minimalRequiredLength);
9858 }
9859
9860 void checkCompatibility() const
9861 {
9862 assert(TemplateId == templateId());
9863
9864 checkSchema<Schema>(schemaId(), version());
9865 checkLength(bufferSize(), version());
9866 }
9867};
9868
9870ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
9871StartOfSnapshot
9872: SbeMessage
9873{
9875 typedef SchemaTraits Schema;
9876
9878 enum { TemplateId = 2101 };
9879
9881 StartOfSnapshot() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
9882
9884 StartOfSnapshot(
9885 const void* data,
9886 EncodedLength length)
9887 : SbeMessage(data, length)
9888 {
9889 checkCompatibility();
9890 }
9891
9893 explicit
9894 StartOfSnapshot(
9895 const SbeMessage& message)
9896 : SbeMessage(message)
9897 {
9898 assert(message.valid());
9899
9900 checkCompatibility();
9901 }
9902
9904 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9905 bool lastMDSeqNum(Uint64& value) const
9906 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9907 {
9908 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
9909
9910 return ordinary(value, offset, NullUint64());
9911 }
9912
9914 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9915 bool snapshotTime(Uint64& value) const
9916 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9917 {
9918 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
9919
9920 return ordinary(value, offset, NullUint64());
9921 }
9922
9924 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9925 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9926 static
9927 BlockLength
9928 minimalBlockLength(
9929 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9930 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9931 {
9932 return
9933 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9934 16;
9935 }
9936
9938 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9939 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9940 static BlockLength blockLength(SchemaVersion version)
9941 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9942 {
9943 return
9944 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9945 minimalBlockLength(version);
9946 }
9947
9949 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9950 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9951 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9952 static
9953 MessageSize
9954 getMinimalVariableFieldsSize(
9955 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
9956 {
9957 return
9958 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
9959 0;
9960 }
9961
9963 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9964 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9965 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9966 static const Char* className()
9967 {
9968 return "StartOfSnapshot";
9969 }
9970
9972 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
9973 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9974 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
9975 static StrRef fixType()
9976 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
9977 {
9978 return constructStrRef("StartOfSnapshot");
9979 }
9980
9982 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
9983 std::string toString() const;
9984
9985private:
9986 void checkLength(
9987 EncodedLength length, SchemaVersion version) const
9988 {
9989 const EncodedLength minimalRequiredLength =
9990 minimalBlockLength(version) +
9991 MessageHeader::Size +
9992 getMinimalVariableFieldsSize(version);
9993
9994 checkBinaryLength(
9995 *this, length, minimalRequiredLength);
9996 }
9997
9998 void checkCompatibility() const
9999 {
10000 assert(TemplateId == templateId());
10001
10002 checkSchema<Schema>(schemaId(), version());
10003 checkLength(bufferSize(), version());
10004 }
10005};
10006
10008ONIXS_EURONEXT_OPTIQMDG_LTWT_STRUCT
10009EndOfSnapshot
10010: SbeMessage
10011{
10013 typedef SchemaTraits Schema;
10014
10016 enum { TemplateId = 2102 };
10017
10019 EndOfSnapshot() ONIXS_EURONEXT_OPTIQMDG_DEFAULT;
10020
10022 EndOfSnapshot(
10023 const void* data,
10024 EncodedLength length)
10025 : SbeMessage(data, length)
10026 {
10027 checkCompatibility();
10028 }
10029
10031 explicit
10032 EndOfSnapshot(
10033 const SbeMessage& message)
10034 : SbeMessage(message)
10035 {
10036 assert(message.valid());
10037
10038 checkCompatibility();
10039 }
10040
10042 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10043 bool lastMDSeqNum(Uint64& value) const
10044 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
10045 {
10046 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 0;
10047
10048 return ordinary(value, offset, NullUint64());
10049 }
10050
10052 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10053 bool snapshotTime(Uint64& value) const
10054 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
10055 {
10056 ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR BlockLength offset = 8;
10057
10058 return ordinary(value, offset, NullUint64());
10059 }
10060
10062 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10063 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
10064 static
10065 BlockLength
10066 minimalBlockLength(
10067 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
10068 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
10069 {
10070 return
10071 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10072 16;
10073 }
10074
10076 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10077 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
10078 static BlockLength blockLength(SchemaVersion version)
10079 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
10080 {
10081 return
10082 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10083 minimalBlockLength(version);
10084 }
10085
10087 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10088 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10089 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
10090 static
10091 MessageSize
10092 getMinimalVariableFieldsSize(
10093 ONIXS_EURONEXT_OPTIQMDG_UNUSED SchemaVersion version)
10094 {
10095 return
10096 ONIXS_EURONEXT_OPTIQMDG_ASSERT(version >= Schema::MinimalVersion),
10097 0;
10098 }
10099
10101 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10102 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10103 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
10104 static const Char* className()
10105 {
10106 return "EndOfSnapshot";
10107 }
10108
10110 ONIXS_EURONEXT_OPTIQMDG_LTWT_EXPORTED
10111 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10112 ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
10113 static StrRef fixType()
10114 ONIXS_EURONEXT_OPTIQMDG_NOTHROW
10115 {
10116 return constructStrRef("EndOfSnapshot");
10117 }
10118
10120 ONIXS_EURONEXT_OPTIQMDG_NODISCARD
10121 std::string toString() const;
10122
10123private:
10124 void checkLength(
10125 EncodedLength length, SchemaVersion version) const
10126 {
10127 const EncodedLength minimalRequiredLength =
10128 minimalBlockLength(version) +
10129 MessageHeader::Size +
10130 getMinimalVariableFieldsSize(version);
10131
10132 checkBinaryLength(
10133 *this, length, minimalRequiredLength);
10134 }
10135
10136 void checkCompatibility() const
10137 {
10138 assert(TemplateId == templateId());
10139
10140 checkSchema<Schema>(schemaId(), version());
10141 checkLength(bufferSize(), version());
10142 }
10143};
10144
10145
10146ONIXS_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:195
ONIXS_EURONEXT_OPTIQMDG_NOTHROW
#define ONIXS_EURONEXT_OPTIQMDG_NOTHROW
Definition Compiler.h:186
ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR
#define ONIXS_EURONEXT_OPTIQMDG_CONST_OR_CONSTEXPR
Definition Compiler.h:188
ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
#define ONIXS_EURONEXT_OPTIQMDG_CONSTEXPR
Definition Compiler.h:189
ONIXS_EURONEXT_OPTIQMDG_UNUSED
#define ONIXS_EURONEXT_OPTIQMDG_UNUSED
Definition Compiler.h:211
ONIXS_EURONEXT_OPTIQMDG_DEFAULT
#define ONIXS_EURONEXT_OPTIQMDG_DEFAULT
Definition Compiler.h:212
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:4683
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:4725
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUint16
IntegralConstant< UInt16, 65535 > NullUint16
Null value for an optional Uint16 field.
Definition Fields.h:4689
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullInt64
IntegralConstant< Int64, -9223372036854775807LL-1 > NullInt64
Null value for an optional Int64 field.
Definition Fields.h:4713
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:4729
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUint64
IntegralConstant< UInt64, 18446744073709551615ULL > NullUint64
Null value for an optional Uint64 field.
Definition Fields.h:4701
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUnsignedChar
IntegralConstant< UInt8, 255 > NullUnsignedChar
Null value for an optional UnsignedChar field.
Definition Fields.h:4677
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:4733
OnixS::Euronext::MarketData::OptiqMdg::Messaging::NullUint32
IntegralConstant< UInt32, 4294967295 > NullUint32
Null value for an optional Uint32 field.
Definition Fields.h:4695
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdQtyinMsrmtUnitNotation
bool miFIdQtyinMsrmtUnitNotation(StrRef &value) const noexcept
Provides access to miFIDQtyinMsrmtUnitNotation field.
Definition Messages.h:8117
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTModificationIndicator
bool efficientMMTModificationIndicator(EfficientMMTModificationIndicator::Enum &value) const noexcept
Provides access to efficientMMTModificationIndicator field.
Definition Messages.h:8233
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTMarketMechanism
bool efficientMMTMarketMechanism(EfficientMMTMarketMechanism::Enum &value) const noexcept
Provides access to efficientMMTMarketMechanism field.
Definition Messages.h:8173
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::ApaFullTradeInformation
ApaFullTradeInformation(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7957
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidPrice
bool mifidPrice(StrRef &value) const noexcept
Provides access to mifidPrice field.
Definition Messages.h:8073
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::priceMultiplierDecimals
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition Messages.h:8371
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:8438
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:7968
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTAgencyCrossTradeIndicator
bool efficientMMTAgencyCrossTradeIndicator(EfficientMMTAgencyCrossTradeIndicator::Enum &value) const noexcept
Provides access to efficientMMTAgencyCrossTradeIndicator field.
Definition Messages.h:8221
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidQuantity
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition Messages.h:8084
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:7998
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:7978
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::priceMultiplier
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition Messages.h:8361
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTTransactionCategory
bool efficientMMTTransactionCategory(EfficientMMTTransactionCategory::Enum &value) const noexcept
Provides access to efficientMMTTransactionCategory field.
Definition Messages.h:8197
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTAlgorithmicIndicator
bool efficientMMTAlgorithmicIndicator(EfficientMMTAlgorithmicIndicator::Enum &value) const noexcept
Provides access to efficientMMTAlgorithmicIndicator field.
Definition Messages.h:8293
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::longTradeReference
bool longTradeReference(StrRef &value) const noexcept
Provides access to longTradeReference field.
Definition Messages.h:8403
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTSpecialDividendIndicator
bool efficientMMTSpecialDividendIndicator(EfficientMMTSpecialDividendIndicator::Enum &value) const noexcept
Provides access to efficientMMTSpecialDividendIndicator field.
Definition Messages.h:8257
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::tradeReference
bool tradeReference(StrRef &value) const noexcept
Provides access to tradeReference field.
Definition Messages.h:8340
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTPublicationMode
bool efficientMMTPublicationMode(EfficientMMTPublicationMode::Enum &value) const noexcept
Provides access to efficientMMTPublicationMode field.
Definition Messages.h:8305
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::venue
StrRef venue() const noexcept
Provides access to venue field.
Definition Messages.h:8381
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidPriceNotation
bool mifidPriceNotation(StrRef &value) const noexcept
Provides access to mifidPriceNotation field.
Definition Messages.h:8095
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidCurrency
bool mifidCurrency(StrRef &value) const noexcept
Provides access to mifidCurrency field.
Definition Messages.h:8106
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdClearingFlag
bool miFIdClearingFlag(StrRef &value) const noexcept
Provides access to miFIDClearingFlag field.
Definition Messages.h:8161
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::notionalCurrency
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition Messages.h:8150
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:8465
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidInstrumentIdType
bool mifidInstrumentIdType(StrRef &value) const noexcept
Provides access to mifidInstrumentIdType field.
Definition Messages.h:8040
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTDuplicativeIndicator
bool efficientMMTDuplicativeIndicator(EfficientMMTDuplicativeIndicator::Enum &value) const noexcept
Provides access to efficientMMTDuplicativeIndicator field.
Definition Messages.h:8329
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:8451
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidQuantityMeasurementUnit
bool mifidQuantityMeasurementUnit(StrRef &value) const noexcept
Provides access to mifidQuantityMeasurementUnit field.
Definition Messages.h:8128
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTBenchmarkIndicator
bool efficientMMTBenchmarkIndicator(EfficientMMTBenchmarkIndicator::Enum &value) const noexcept
Provides access to efficientMMTBenchmarkIndicator field.
Definition Messages.h:8245
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::publicationDateTime
bool publicationDateTime(StrRef &value) const noexcept
Provides access to publicationDateTime field.
Definition Messages.h:8019
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:8486
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTOffBookAutomatedIndicator
bool efficientMMTOffBookAutomatedIndicator(EfficientMMTOffBookAutomatedIndicator::Enum &value) const noexcept
Provides access to efficientMMTOffBookAutomatedIndicator field.
Definition Messages.h:8269
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdTransactionId
StrRef miFIdTransactionId() const noexcept
Provides access to miFIDTransactionID field.
Definition Messages.h:8062
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::tradeType
TradeType::Enum tradeType() const noexcept
Provides access to tradeType field.
Definition Messages.h:8030
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::originalReportTimestamp
bool originalReportTimestamp(Uint64 &value) const noexcept
Provides access to originalReportTimestamp field.
Definition Messages.h:8351
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTTradingMode
bool efficientMMTTradingMode(EfficientMMTTradingMode::Enum &value) const noexcept
Provides access to efficientMMTTradingMode field.
Definition Messages.h:8185
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTPostTradeDeferral
bool efficientMMTPostTradeDeferral(EfficientMMTPostTradeDeferral::Enum &value) const noexcept
Provides access to efficientMMTPostTradeDeferral field.
Definition Messages.h:8317
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:7988
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::tradeUniqueIdentifier
bool tradeUniqueIdentifier(StrRef &value) const noexcept
Provides access to tradeUniqueIdentifier field.
Definition Messages.h:8425
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdEmissionAllowanceType
bool miFIdEmissionAllowanceType(StrRef &value) const noexcept
Provides access to miFIDEmissionAllowanceType field.
Definition Messages.h:8392
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::mifidInstrumentId
bool mifidInstrumentId(StrRef &value) const noexcept
Provides access to mifidInstrumentID field.
Definition Messages.h:8051
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTNegotiationIndicator
bool efficientMMTNegotiationIndicator(EfficientMMTNegotiationIndicator::Enum &value) const noexcept
Provides access to efficientMMTNegotiationIndicator field.
Definition Messages.h:8209
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::aPAOrigin
bool aPAOrigin(StrRef &value) const noexcept
Provides access to aPAOrigin field.
Definition Messages.h:8414
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::tradingDateTime
StrRef tradingDateTime() const noexcept
Provides access to tradingDateTime field.
Definition Messages.h:8008
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::miFIdNotionalAmount
bool miFIdNotionalAmount(StrRef &value) const noexcept
Provides access to miFIDNotionalAmount field.
Definition Messages.h:8139
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaFullTradeInformation::efficientMMTContributiontoPrice
bool efficientMMTContributiontoPrice(EfficientMMTContributiontoPrice::Enum &value) const noexcept
Provides access to efficientMMTContributiontoPrice field.
Definition Messages.h:8281
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mifidPrice
StrRef mifidPrice() const noexcept
Provides access to mifidPrice field.
Definition Messages.h:7486
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::ApaQuotes
ApaQuotes(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7380
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7522
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:7391
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mifidQuantity
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition Messages.h:7497
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:7466
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:7401
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mifidInstrumentId
StrRef mifidInstrumentId() const noexcept
Provides access to mifidInstrumentID field.
Definition Messages.h:7422
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mIC
StrRef mIC() const noexcept
Provides access to mIC field.
Definition Messages.h:7433
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::mifidInstrumentIdType
StrRef mifidInstrumentIdType() const noexcept
Provides access to mifidInstrumentIdType field.
Definition Messages.h:7411
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::lEICode
StrRef lEICode() const noexcept
Provides access to lEICode field.
Definition Messages.h:7455
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:7476
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:7548
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7534
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7569
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::currency
StrRef currency() const noexcept
Provides access to currency field.
Definition Messages.h:7444
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaQuotes::aPAOrigin
bool aPAOrigin(StrRef &value) const noexcept
Provides access to aPAOrigin field.
Definition Messages.h:7508
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::priceMultiplierDecimals
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition Messages.h:7733
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7853
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:7637
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::optionType
bool optionType(OptionType::Enum &value) const noexcept
Provides access to optionType field.
Definition Messages.h:7776
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:7647
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::priceMultiplier
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition Messages.h:7723
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::mifidInstrumentId
StrRef mifidInstrumentId() const noexcept
Provides access to mifidInstrumentID field.
Definition Messages.h:7668
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::mifidInstrumentIdType
StrRef mifidInstrumentIdType() const noexcept
Provides access to mifidInstrumentIdType field.
Definition Messages.h:7657
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::maturityDate
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition Messages.h:7818
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::cFI
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition Messages.h:7690
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::underlyingISINCode
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition Messages.h:7743
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::exerStyle
bool exerStyle(ExerciseStyle::Enum &value) const noexcept
Provides access to exerStyle field.
Definition Messages.h:7807
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::notionalCurrency
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition Messages.h:7701
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:7879
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::secondNotionalCurrency
bool secondNotionalCurrency(StrRef &value) const noexcept
Provides access to secondNotionalCurrency field.
Definition Messages.h:7712
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7865
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7900
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::underlyingIndexTerm
bool underlyingIndexTerm(StrRef &value) const noexcept
Provides access to underlyingIndexTerm field.
Definition Messages.h:7765
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::strikePriceDecimals
bool strikePriceDecimals(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimals field.
Definition Messages.h:7796
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::ApaStandingData
ApaStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7626
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::strikePrice
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition Messages.h:7786
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::expiryDate
bool expiryDate(StrRef &value) const noexcept
Provides access to expiryDate field.
Definition Messages.h:7829
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::settlementMethod
bool settlementMethod(Char &value) const noexcept
Provides access to settlementMethod field.
Definition Messages.h:7840
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::fullInstrumentName
bool fullInstrumentName(StrRef &value) const noexcept
Provides access to fullInstrumentName field.
Definition Messages.h:7679
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ApaStandingData::underlyingIndexName
bool underlyingIndexName(StrRef &value) const noexcept
Provides access to underlyingIndexName field.
Definition Messages.h:7754
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::InterestPaymentDateRepEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:8586
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:8548
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::InterestPaymentDateRepEntry::interestPaymentDate
bool interestPaymentDate(Uint16 &value) const noexcept
Provides access to interestPaymentDate field.
Definition Messages.h:8560
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dividendCurrency
bool dividendCurrency(StrRef &value) const noexcept
Provides access to dividendCurrency field.
Definition Messages.h:8836
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::priceIndexLevelDecimals
bool priceIndexLevelDecimals(UnsignedChar &value) const noexcept
Provides access to priceIndexLevelDecimals field.
Definition Messages.h:9007
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::issueDate
bool issueDate(Uint16 &value) const noexcept
Provides access to issueDate field.
Definition Messages.h:8920
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9060
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:8635
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dividendRecordDate
bool dividendRecordDate(Uint16 &value) const noexcept
Provides access to dividendRecordDate field.
Definition Messages.h:8847
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::BfInstrumentReference
BfInstrumentReference(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:8624
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:8645
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::paymentFrequency
bool paymentFrequency(PaymentFrequency::Enum &value) const noexcept
Provides access to paymentFrequency field.
Definition Messages.h:8953
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::issuingCountry
bool issuingCountry(StrRef &value) const noexcept
Provides access to issuingCountry field.
Definition Messages.h:8930
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::iSINCode
bool iSINCode(StrRef &value) const noexcept
Provides access to iSINCode field.
Definition Messages.h:8675
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::mIC
bool mIC(StrRef &value) const noexcept
Provides access to mIC field.
Definition Messages.h:8815
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::instrumentCategory
InstrumentCategory::Enum instrumentCategory() const noexcept
Provides access to instrumentCategory field.
Definition Messages.h:8974
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dividendPaymentDate
bool dividendPaymentDate(Uint16 &value) const noexcept
Provides access to dividendPaymentDate field.
Definition Messages.h:8877
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::maturityDate
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition Messages.h:8794
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::amountDecimals
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition Messages.h:9027
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::grossDividendPayablePerUnit
bool grossDividendPayablePerUnit(Int64 &value) const noexcept
Provides access to grossDividendPayablePerUnit field.
Definition Messages.h:8826
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::cFI
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition Messages.h:8941
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::grossDividendInEuros
bool grossDividendInEuros(Int64 &value) const noexcept
Provides access to grossDividendInEuros field.
Definition Messages.h:8910
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:8655
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::exDividendDate
bool exDividendDate(Uint16 &value) const noexcept
Provides access to exDividendDate field.
Definition Messages.h:8867
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::closingPrice
bool closingPrice(Int64 &value) const noexcept
Provides access to closingPrice field.
Definition Messages.h:8805
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::longInstrumentName
bool longInstrumentName(StrRef &value) const noexcept
Provides access to longInstrumentName field.
Definition Messages.h:8708
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::coupon
bool coupon(Int64 &value) const noexcept
Provides access to coupon field.
Definition Messages.h:8784
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::sEDOLCode
bool sEDOLCode(StrRef &value) const noexcept
Provides access to sEDOLCode field.
Definition Messages.h:8686
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::optiqSegment
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition Messages.h:8665
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:9086
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dividendRate
bool dividendRate(Uint64 &value) const noexcept
Provides access to dividendRate field.
Definition Messages.h:8857
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::quantityDecimals
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition Messages.h:9017
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::miFIdPriceNotation
bool miFIdPriceNotation(StrRef &value) const noexcept
Provides access to miFIDPriceNotation field.
Definition Messages.h:8996
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9072
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9107
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::shareAmountInIssue
bool shareAmountInIssue(Int64 &value) const noexcept
Provides access to shareAmountInIssue field.
Definition Messages.h:8740
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::longIssuerName
bool longIssuerName(StrRef &value) const noexcept
Provides access to longIssuerName field.
Definition Messages.h:8697
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::minimumAmount
bool minimumAmount(Int64 &value) const noexcept
Provides access to minimumAmount field.
Definition Messages.h:8964
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::lastNAVPrice
bool lastNAVPrice(Int64 &value) const noexcept
Provides access to lastNAVPrice field.
Definition Messages.h:8762
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::nextMeeting
bool nextMeeting(StrRef &value) const noexcept
Provides access to nextMeeting field.
Definition Messages.h:8899
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::openedClosedFund
bool openedClosedFund(OpenedClosedFund::Enum &value) const noexcept
Provides access to openedClosedFund field.
Definition Messages.h:8751
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::InterestPaymentDateRep
SbeGroup< InterestPaymentDateRepEntry, GroupSizeEncoding, MessageSize > InterestPaymentDateRep
Repeating group containing InterestPaymentDateRepEntry entries.
Definition Messages.h:8608
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::currency
bool currency(StrRef &value) const noexcept
Provides access to currency field.
Definition Messages.h:8719
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::grossOfCDSCIndicator
bool grossOfCDSCIndicator(GrossofCDSCIndicator::Enum &value) const noexcept
Provides access to grossOfCDSCIndicator field.
Definition Messages.h:8773
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::ratioMultiplierDecimals
bool ratioMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to ratioMultiplierDecimals field.
Definition Messages.h:9037
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::dateOfInitialListing
bool dateOfInitialListing(Uint16 &value) const noexcept
Provides access to dateOfInitialListing field.
Definition Messages.h:8730
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::taxDescriptionAttachingToADividend
bool taxDescriptionAttachingToADividend(TaxDescriptionAttachingtoaDividend::Enum &value) const noexcept
Provides access to taxDescriptionAttachingToADividend field.
Definition Messages.h:8888
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentReference::securityCondition
bool securityCondition(SecurityCondition::Enum &value) const noexcept
Provides access to securityCondition field.
Definition Messages.h:8985
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9790
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:9735
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:9765
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:9745
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:9755
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:9816
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9802
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9837
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::BfInstrumentSuspension
BfInstrumentSuspension(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:9724
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfInstrumentSuspension::securityCondition
bool securityCondition(SecurityCondition::Enum &value) const noexcept
Provides access to securityCondition field.
Definition Messages.h:9776
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::quantity
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition Messages.h:9299
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9400
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:9197
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:9238
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:9207
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTModificationIndicator
StrRef mMTModificationIndicator() const noexcept
Provides access to mMTModificationIndicator field.
Definition Messages.h:9258
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTSpecialDividendIndicator
bool mMTSpecialDividendIndicator(StrRef &value) const noexcept
Provides access to mMTSpecialDividendIndicator field.
Definition Messages.h:9331
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::tradingCurrency
bool tradingCurrency(StrRef &value) const noexcept
Provides access to tradingCurrency field.
Definition Messages.h:9386
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTAgencyCrossTradeIndicator
bool mMTAgencyCrossTradeIndicator(StrRef &value) const noexcept
Provides access to mMTAgencyCrossTradeIndicator field.
Definition Messages.h:9309
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:9217
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::price
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition Messages.h:9269
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::quantityNotation
bool quantityNotation(StrRef &value) const noexcept
Provides access to quantityNotation field.
Definition Messages.h:9365
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:9376
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:9426
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::BfTrade
BfTrade(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:9186
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::bidOfferDateTime
bool bidOfferDateTime(Uint64 &value) const noexcept
Provides access to bidOfferDateTime field.
Definition Messages.h:9248
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::miFIdPriceNotation
bool miFIdPriceNotation(StrRef &value) const noexcept
Provides access to miFIDPriceNotation field.
Definition Messages.h:9354
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9412
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTTradingMode
bool mMTTradingMode(MmtTradingMode::Enum &value) const noexcept
Provides access to mMTTradingMode field.
Definition Messages.h:9343
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9447
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::bidPrice
bool bidPrice(Int64 &value) const noexcept
Provides access to bidPrice field.
Definition Messages.h:9279
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::miFIdTransactionId
StrRef miFIdTransactionId() const noexcept
Provides access to miFIDTransactionID field.
Definition Messages.h:9227
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::mMTBenchmarkIndicator
bool mMTBenchmarkIndicator(StrRef &value) const noexcept
Provides access to mMTBenchmarkIndicator field.
Definition Messages.h:9320
OnixS::Euronext::MarketData::OptiqMdg::Messaging::BfTrade::offerPrice
bool offerPrice(Int64 &value) const noexcept
Provides access to offerPrice field.
Definition Messages.h:9289
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:9620
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:9515
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:9587
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:9525
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::mMTModificationIndicator
StrRef mMTModificationIndicator() const noexcept
Provides access to mMTModificationIndicator field.
Definition Messages.h:9566
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::nAVOfferPrice
bool nAVOfferPrice(Int64 &value) const noexcept
Provides access to nAVOfferPrice field.
Definition Messages.h:9607
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::nAVPrice
bool nAVPrice(Int64 &value) const noexcept
Provides access to nAVPrice field.
Definition Messages.h:9577
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:9535
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:9646
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::bidOfferDateTime
bool bidOfferDateTime(Uint64 &value) const noexcept
Provides access to bidOfferDateTime field.
Definition Messages.h:9545
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9632
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9667
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:9555
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::nAVBidPrice
bool nAVBidPrice(Int64 &value) const noexcept
Provides access to nAVBidPrice field.
Definition Messages.h:9597
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Bfnav::Bfnav
Bfnav(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:9504
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:5461
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::patternId
bool patternId(Uint16 &value) const noexcept
Provides access to patternID field.
Definition Messages.h:5493
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:5573
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::eMM
bool eMM(Emm::Enum &value) const noexcept
Provides access to eMM field.
Definition Messages.h:5473
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::dynamicCollarLogic
bool dynamicCollarLogic(DynamicCollarLogic::Enum &value) const noexcept
Provides access to dynamicCollarLogic field.
Definition Messages.h:5526
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::lotSize
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition Messages.h:5503
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::collarUnhaltDelay
bool collarUnhaltDelay(Uint32 &value) const noexcept
Provides access to collarUnhaltDelay field.
Definition Messages.h:5547
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::collarMaxUnhaltNb
bool collarMaxUnhaltNb(UnsignedChar &value) const noexcept
Provides access to collarMaxUnhaltNb field.
Definition Messages.h:5537
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::strategyAuthorized
bool strategyAuthorized(StrategyAuthorized &value) const noexcept
Provides access to strategyAuthorized field.
Definition Messages.h:5514
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMPropertiesEntry::tickSizeIndexId
bool tickSizeIndexId(Uint16 &value) const noexcept
Provides access to tickSizeIndexID field.
Definition Messages.h:5483
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::settlementTickSize
bool settlementTickSize(Uint64 &value) const noexcept
Provides access to settlementTickSize field.
Definition Messages.h:5950
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingMIC
bool underlyingMIC(StrRef &value) const noexcept
Provides access to underlyingMIC field.
Definition Messages.h:5821
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::orderTypeRules
OrderTypeRules orderTypeRules() const noexcept
Provides access to orderTypeRules field.
Definition Messages.h:5853
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6112
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::priceDecimals
bool priceDecimals(UnsignedChar &value) const noexcept
Provides access to priceDecimals field.
Definition Messages.h:5737
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::lotMultiplier
bool lotMultiplier(Uint64 &value) const noexcept
Provides access to lotMultiplier field.
Definition Messages.h:6090
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:5622
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:5632
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractStandingData
ContractStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:5611
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::contractEventDate
bool contractEventDate(Uint16 &value) const noexcept
Provides access to contractEventDate field.
Definition Messages.h:5672
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::mIC
StrRef mIC() const noexcept
Provides access to mIC field.
Definition Messages.h:5788
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ratioDecimals
bool ratioDecimals(UnsignedChar &value) const noexcept
Provides access to ratioDecimals field.
Definition Messages.h:5767
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::mainDepositary
bool mainDepositary(StrRef &value) const noexcept
Provides access to mainDepositary field.
Definition Messages.h:5777
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::tradingCurrency
StrRef tradingCurrency() const noexcept
Provides access to tradingCurrency field.
Definition Messages.h:5873
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::collarExpansionFactor
bool collarExpansionFactor(UnsignedChar &value) const noexcept
Provides access to collarExpansionFactor field.
Definition Messages.h:6060
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::eDSPTickSize
bool eDSPTickSize(Uint64 &value) const noexcept
Provides access to eDSPTickSize field.
Definition Messages.h:5960
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::contractTradingType
ContractTradingType::Enum contractTradingType() const noexcept
Provides access to contractTradingType field.
Definition Messages.h:5905
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::amountDecimals
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition Messages.h:5757
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingSymbolIndex
bool underlyingSymbolIndex(Uint32 &value) const noexcept
Provides access to underlyingSymbolIndex field.
Definition Messages.h:5970
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingISINCode
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition Messages.h:5832
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::referenceSpreadTableId
bool referenceSpreadTableId(Uint16 &value) const noexcept
Provides access to referenceSpreadTableID field.
Definition Messages.h:5992
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::strikePriceDecimalsRatio
bool strikePriceDecimalsRatio(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimalsRatio field.
Definition Messages.h:5884
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::exerStyle
bool exerStyle(ExerciseStyle::Enum &value) const noexcept
Provides access to exerStyle field.
Definition Messages.h:5693
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::tradingUnit
bool tradingUnit(Uint64 &value) const noexcept
Provides access to tradingUnit field.
Definition Messages.h:6014
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:5642
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::referencePriceOriginInOpeningCall
bool referencePriceOriginInOpeningCall(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInOpeningCall field.
Definition Messages.h:6025
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::instUnitExp
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition Messages.h:5916
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::contractName
StrRef contractName() const noexcept
Provides access to contractName field.
Definition Messages.h:5704
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::optiqSegment
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition Messages.h:5652
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::mMProtections
MmProtections mMProtections() const noexcept
Provides access to mMProtections field.
Definition Messages.h:5894
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:6139
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::quantityDecimals
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition Messages.h:5747
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6125
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingSubtype
bool underlyingSubtype(UnderlyingSubtype::Enum &value) const noexcept
Provides access to underlyingSubtype field.
Definition Messages.h:5928
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:6160
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::ContractEMMProperties
SbeGroup< ContractEMMPropertiesEntry, GroupSizeEncoding, MessageSize > ContractEMMProperties
Repeating group containing ContractEMMPropertiesEntry entries.
Definition Messages.h:5595
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingType
UnderlyingType::Enum underlyingType() const noexcept
Provides access to underlyingType field.
Definition Messages.h:5727
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::tradingPolicy
bool tradingPolicy(TradingPolicy::Enum &value) const noexcept
Provides access to tradingPolicy field.
Definition Messages.h:5981
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::productCode
StrRef productCode() const noexcept
Provides access to productCode field.
Definition Messages.h:5810
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::referencePriceOriginInContinuous
bool referencePriceOriginInContinuous(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInContinuous field.
Definition Messages.h:6037
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::referencePriceOriginInTradingInterruption
bool referencePriceOriginInTradingInterruption(ReferencePriceOrigin::Enum &value) const noexcept
Provides access to referencePriceOriginInTradingInterruption field.
Definition Messages.h:6049
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::mIFIdIILiquidFlag
bool mIFIdIILiquidFlag(UnsignedChar &value) const noexcept
Provides access to mIFIDIILiquidFlag field.
Definition Messages.h:6070
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::exchangeCode
ExchangeCode::Enum exchangeCode() const noexcept
Provides access to exchangeCode field.
Definition Messages.h:5682
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::derivativesMarketModel
bool derivativesMarketModel(DerivativesMarketModel::Enum &value) const noexcept
Provides access to derivativesMarketModel field.
Definition Messages.h:6003
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::partitionId
bool partitionId(Uint16 &value) const noexcept
Provides access to partitionID field.
Definition Messages.h:5662
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::settlementMethod
bool settlementMethod(Char &value) const noexcept
Provides access to settlementMethod field.
Definition Messages.h:5863
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::contractType
bool contractType(ContractType::Enum &value) const noexcept
Provides access to contractType field.
Definition Messages.h:5716
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::pricingAlgorithm
PricingAlgorithm::Enum pricingAlgorithm() const noexcept
Provides access to pricingAlgorithm field.
Definition Messages.h:6080
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::motherStockISIN
bool motherStockISIN(StrRef &value) const noexcept
Provides access to motherStockISIN field.
Definition Messages.h:5939
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::countryOfExchange
StrRef countryOfExchange() const noexcept
Provides access to countryOfExchange field.
Definition Messages.h:5799
OnixS::Euronext::MarketData::OptiqMdg::Messaging::ContractStandingData::underlyingExpiry
bool underlyingExpiry(Uint32 &value) const noexcept
Provides access to underlyingExpiry field.
Definition Messages.h:5843
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:230
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:207
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:256
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:242
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:277
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::EndOfDay
EndOfDay(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:196
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfDay::sessionTradingDay
bool sessionTradingDay(Uint16 &value) const noexcept
Provides access to sessionTradingDay field.
Definition Messages.h:217
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:10066
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::lastMDSeqNum
bool lastMDSeqNum(Uint64 &value) const noexcept
Provides access to lastMDSeqNum field.
Definition Messages.h:10043
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::EndOfSnapshot
EndOfSnapshot(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:10032
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::snapshotTime
bool snapshotTime(Uint64 &value) const noexcept
Provides access to snapshotTime field.
Definition Messages.h:10053
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:10092
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:10078
OnixS::Euronext::MarketData::OptiqMdg::Messaging::EndOfSnapshot::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:10113
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:1668
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:1640
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::NotUsedGroup1Entry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:1636
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::NotUsedGroup1Entry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1654
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTOffBookAutomatedIndicator
bool mMTOffBookAutomatedIndicator(MmtOffBookAutomatedIndicator::Enum &value) const noexcept
Provides access to mMTOffBookAutomatedIndicator field.
Definition Messages.h:2022
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::miFIdQtyinMsrmtUnitNotation
bool miFIdQtyinMsrmtUnitNotation(StrRef &value) const noexcept
Provides access to miFIDQtyinMsrmtUnitNotation field.
Definition Messages.h:1876
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::evaluatedPrice
bool evaluatedPrice(Int64 &value) const noexcept
Provides access to evaluatedPrice field.
Definition Messages.h:2250
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidPrice
bool mifidPrice(StrRef &value) const noexcept
Provides access to mifidPrice field.
Definition Messages.h:1832
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::priceMultiplierDecimals
bool priceMultiplierDecimals(UnsignedChar &value) const noexcept
Provides access to priceMultiplierDecimals field.
Definition Messages.h:2187
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:2411
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:1717
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::transparencyIndicator
bool transparencyIndicator(TransparencyIndicator::Enum &value) const noexcept
Provides access to transparencyIndicator field.
Definition Messages.h:2156
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidQuantity
StrRef mifidQuantity() const noexcept
Provides access to mifidQuantity field.
Definition Messages.h:1843
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidExecutionId
StrRef mifidExecutionId() const noexcept
Provides access to mifidExecutionID field.
Definition Messages.h:1821
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:1747
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:1727
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::priceMultiplier
bool priceMultiplier(Uint32 &value) const noexcept
Provides access to priceMultiplier field.
Definition Messages.h:2177
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::blockTradeCode
bool blockTradeCode(BlockTradeCode::Enum &value) const noexcept
Provides access to blockTradeCode field.
Definition Messages.h:2123
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTSpecialDividendIndicator
bool mMTSpecialDividendIndicator(StrRef &value) const noexcept
Provides access to mMTSpecialDividendIndicator field.
Definition Messages.h:2010
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::venueofPublication
bool venueofPublication(StrRef &value) const noexcept
Provides access to venueofPublication field.
Definition Messages.h:2376
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::marketOfReferenceMIC
bool marketOfReferenceMIC(StrRef &value) const noexcept
Provides access to marketOfReferenceMIC field.
Definition Messages.h:2239
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTAgencyCrossTradeIndicator
bool mMTAgencyCrossTradeIndicator(StrRef &value) const noexcept
Provides access to mMTAgencyCrossTradeIndicator field.
Definition Messages.h:1977
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPublicationModeIlliquid
bool mMTPublicationModeIlliquid(StrRef &value) const noexcept
Provides access to mMTPublicationModeIlliquid field.
Definition Messages.h:2352
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradeReference
bool tradeReference(StrRef &value) const noexcept
Provides access to tradeReference field.
Definition Messages.h:2134
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTDuplicativeIndicator
bool mMTDuplicativeIndicator(StrRef &value) const noexcept
Provides access to mMTDuplicativeIndicator field.
Definition Messages.h:2077
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTContingentTransactionIndicator
bool mMTContingentTransactionIndicator(StrRef &value) const noexcept
Provides access to mMTContingentTransactionIndicator field.
Definition Messages.h:2340
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::venue
StrRef venue() const noexcept
Provides access to venue field.
Definition Messages.h:2197
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:1757
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTModificationIndicator
bool mMTModificationIndicator(StrRef &value) const noexcept
Provides access to mMTModificationIndicator field.
Definition Messages.h:1988
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPreTradeTransparencyWaiverRelatedtoSizeandScale
bool mMTPreTradeTransparencyWaiverRelatedtoSizeandScale(StrRef &value) const noexcept
Provides access to mMTPreTradeTransparencyWaiverRelatedtoSizeandScale field.
Definition Messages.h:2316
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradeQualifier
TradeQualifier tradeQualifier() const noexcept
Provides access to tradeQualifier field.
Definition Messages.h:2088
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidPriceNotation
bool mifidPriceNotation(StrRef &value) const noexcept
Provides access to mifidPriceNotation field.
Definition Messages.h:1854
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::repoSettlementDate
bool repoSettlementDate(Uint16 &value) const noexcept
Provides access to repoSettlementDate field.
Definition Messages.h:2282
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidCurrency
bool mifidCurrency(StrRef &value) const noexcept
Provides access to mifidCurrency field.
Definition Messages.h:1865
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::miFIdClearingFlag
bool miFIdClearingFlag(StrRef &value) const noexcept
Provides access to miFIDClearingFlag field.
Definition Messages.h:1920
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::notionalCurrency
bool notionalCurrency(StrRef &value) const noexcept
Provides access to notionalCurrency field.
Definition Messages.h:1909
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:2442
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidInstrumentIdType
bool mifidInstrumentIdType(StrRef &value) const noexcept
Provides access to mifidInstrumentIdType field.
Definition Messages.h:1799
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:2428
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTTradingMode
bool mMTTradingMode(MmtTradingMode::Enum &value) const noexcept
Provides access to mMTTradingMode field.
Definition Messages.h:1944
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidQuantityMeasurementUnit
bool mifidQuantityMeasurementUnit(StrRef &value) const noexcept
Provides access to mifidQuantityMeasurementUnit field.
Definition Messages.h:1887
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::messagePriceNotation
bool messagePriceNotation(MessagePriceNotation::Enum &value) const noexcept
Provides access to messagePriceNotation field.
Definition Messages.h:2261
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::publicationDateTime
bool publicationDateTime(StrRef &value) const noexcept
Provides access to publicationDateTime field.
Definition Messages.h:1778
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:2463
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPublicationModeSizeSpecific
bool mMTPublicationModeSizeSpecific(StrRef &value) const noexcept
Provides access to mMTPublicationModeSizeSpecific field.
Definition Messages.h:2364
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::settlementDate
bool settlementDate(Uint16 &value) const noexcept
Provides access to settlementDate field.
Definition Messages.h:2272
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::transactionType
bool transactionType(TransactionType::Enum &value) const noexcept
Provides access to transactionType field.
Definition Messages.h:2099
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradeType
TradeType::Enum tradeType() const noexcept
Provides access to tradeType field.
Definition Messages.h:1789
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::missingPrice
bool missingPrice(StrRef &value) const noexcept
Provides access to missingPrice field.
Definition Messages.h:2304
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::originalReportTimestamp
bool originalReportTimestamp(Uint64 &value) const noexcept
Provides access to originalReportTimestamp field.
Definition Messages.h:2145
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTNegotiationIndicator
bool mMTNegotiationIndicator(StrRef &value) const noexcept
Provides access to mMTNegotiationIndicator field.
Definition Messages.h:1966
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPortfolioTransactionIndicator
bool mMTPortfolioTransactionIndicator(StrRef &value) const noexcept
Provides access to mMTPortfolioTransactionIndicator field.
Definition Messages.h:2328
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::effectiveDateIndicator
bool effectiveDateIndicator(EffectiveDateIndicator::Enum &value) const noexcept
Provides access to effectiveDateIndicator field.
Definition Messages.h:2111
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTContributiontoPrice
bool mMTContributiontoPrice(StrRef &value) const noexcept
Provides access to mMTContributiontoPrice field.
Definition Messages.h:2033
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::NotUsedGroup1
SbeGroup< NotUsedGroup1Entry, GroupSizeEncoding, MessageSize > NotUsedGroup1
Repeating group containing NotUsedGroup1Entry entries.
Definition Messages.h:1690
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTAlgorithmicIndicator
bool mMTAlgorithmicIndicator(StrRef &value) const noexcept
Provides access to mMTAlgorithmicIndicator field.
Definition Messages.h:2044
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPublicationMode
bool mMTPublicationMode(StrRef &value) const noexcept
Provides access to mMTPublicationMode field.
Definition Messages.h:2055
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:1737
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTBenchmarkIndicator
bool mMTBenchmarkIndicator(StrRef &value) const noexcept
Provides access to mMTBenchmarkIndicator field.
Definition Messages.h:1999
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTPostTradeDeferral
bool mMTPostTradeDeferral(StrRef &value) const noexcept
Provides access to mMTPostTradeDeferral field.
Definition Messages.h:2066
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradeUniqueIdentifier
bool tradeUniqueIdentifier(StrRef &value) const noexcept
Provides access to tradeUniqueIdentifier field.
Definition Messages.h:2292
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::endTimeVwap
bool endTimeVwap(Uint32 &value) const noexcept
Provides access to endTimeVwap field.
Definition Messages.h:2218
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::miFIdEmissionAllowanceType
bool miFIdEmissionAllowanceType(StrRef &value) const noexcept
Provides access to miFIDEmissionAllowanceType field.
Definition Messages.h:2228
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mifidInstrumentId
bool mifidInstrumentId(StrRef &value) const noexcept
Provides access to mifidInstrumentID field.
Definition Messages.h:1810
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::FullTradeInformation
FullTradeInformation(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:1706
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::startTimeVwap
bool startTimeVwap(Uint32 &value) const noexcept
Provides access to startTimeVwap field.
Definition Messages.h:2208
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::currencyCoefficient
bool currencyCoefficient(Uint32 &value) const noexcept
Provides access to currencyCoefficient field.
Definition Messages.h:2167
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTTransactionCategory
bool mMTTransactionCategory(StrRef &value) const noexcept
Provides access to mMTTransactionCategory field.
Definition Messages.h:1955
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::tradingDateTime
StrRef tradingDateTime() const noexcept
Provides access to tradingDateTime field.
Definition Messages.h:1767
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::mMTMarketMechanism
bool mMTMarketMechanism(MmtMarketMechanism::Enum &value) const noexcept
Provides access to mMTMarketMechanism field.
Definition Messages.h:1932
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::postTradeDeferralFlags
bool postTradeDeferralFlags(StrRef &value) const noexcept
Provides access to postTradeDeferralFlags field.
Definition Messages.h:2388
OnixS::Euronext::MarketData::OptiqMdg::Messaging::FullTradeInformation::miFIdNotionalAmount
bool miFIdNotionalAmount(StrRef &value) const noexcept
Provides access to miFIDNotionalAmount field.
Definition Messages.h:1898
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:368
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:345
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:355
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::HealthStatus
HealthStatus(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:334
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:394
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:380
OnixS::Euronext::MarketData::OptiqMdg::Messaging::HealthStatus::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:415
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::closingReferenceTime
bool closingReferenceTime(Uint64 &value) const noexcept
Provides access to closingReferenceTime field.
Definition Messages.h:4907
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4990
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:4807
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:4837
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:4817
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::openingTime
bool openingTime(Uint64 &value) const noexcept
Provides access to openingTime field.
Definition Messages.h:4867
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::prctVarfromPrevClose
bool prctVarfromPrevClose(Int64 &value) const noexcept
Provides access to prctVarfromPrevClose field.
Definition Messages.h:4917
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::highLevel
bool highLevel(Int64 &value) const noexcept
Provides access to highLevel field.
Definition Messages.h:4927
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::openingLevel
bool openingLevel(Int64 &value) const noexcept
Provides access to openingLevel field.
Definition Messages.h:4857
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:4847
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::lowLevel
bool lowLevel(Int64 &value) const noexcept
Provides access to lowLevel field.
Definition Messages.h:4947
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:5016
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5002
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:5037
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::closingReferenceLevel
bool closingReferenceLevel(Int64 &value) const noexcept
Provides access to closingReferenceLevel field.
Definition Messages.h:4897
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::liquidationTime
bool liquidationTime(Uint64 &value) const noexcept
Provides access to liquidationTime field.
Definition Messages.h:4977
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:4827
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::lowTime
bool lowTime(Uint64 &value) const noexcept
Provides access to lowTime field.
Definition Messages.h:4957
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::IndexSummary
IndexSummary(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4796
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::confirmedReferenceTime
bool confirmedReferenceTime(Uint64 &value) const noexcept
Provides access to confirmedReferenceTime field.
Definition Messages.h:4887
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::confirmedReferenceLevel
bool confirmedReferenceLevel(Int64 &value) const noexcept
Provides access to confirmedReferenceLevel field.
Definition Messages.h:4877
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::liquidationLevel
bool liquidationLevel(Int64 &value) const noexcept
Provides access to liquidationLevel field.
Definition Messages.h:4967
OnixS::Euronext::MarketData::OptiqMdg::Messaging::IndexSummary::highTime
bool highTime(Uint64 &value) const noexcept
Provides access to highTime field.
Definition Messages.h:4937
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:7065
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:7121
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::legLastQty
bool legLastQty(Uint64 &value) const noexcept
Provides access to legLastQty field.
Definition Messages.h:7095
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:7049
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::legLastPx
bool legLastPx(Int64 &value) const noexcept
Provides access to legLastPx field.
Definition Messages.h:7085
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::legRatio
bool legRatio(Uint32 &value) const noexcept
Provides access to legRatio field.
Definition Messages.h:7075
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponentsEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:7107
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:7053
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7254
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:7170
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::mifidExecutionId
StrRef mifidExecutionId() const noexcept
Provides access to mifidExecutionID field.
Definition Messages.h:7220
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:7200
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
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:7210
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:7280
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7266
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7301
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:7190
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::PackageComponents
SbeGroup< PackageComponentsEntry, GroupSizeEncoding, MessageSize > PackageComponents
Repeating group containing PackageComponentsEntry entries.
Definition Messages.h:7143
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::strategyCode
StrategyCode::Enum strategyCode() const noexcept
Provides access to strategyCode field.
Definition Messages.h:7231
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LisPackageStructure::LisPackageStructure
LisPackageStructure(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7159
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:6823
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::previousPriority
bool previousPriority(Uint64 &value) const noexcept
Provides access to previousPriority field.
Definition Messages.h:6726
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderPx
bool orderPx(Int64 &value) const noexcept
Provides access to orderPx field.
Definition Messages.h:6746
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderQuantity
bool orderQuantity(Uint64 &value) const noexcept
Provides access to orderQuantity field.
Definition Messages.h:6766
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::className
static constexpr const Char * className()
Entity class name.
Definition Messages.h:6836
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:6683
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderSide
bool orderSide(OrderSide::Enum &value) const noexcept
Provides access to orderSide field.
Definition Messages.h:6756
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::pegOffset
bool pegOffset(Int8 &value) const noexcept
Provides access to pegOffset field.
Definition Messages.h:6776
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:6695
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:6679
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:6809
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderType
bool orderType(OrderType::Enum &value) const noexcept
Provides access to orderType field.
Definition Messages.h:6736
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::accountType
AccountType::Enum accountType() const noexcept
Provides access to accountType field.
Definition Messages.h:6797
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::actionType
MarketDataActionType::Enum actionType() const noexcept
Provides access to actionType field.
Definition Messages.h:6706
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::firmId
StrRef firmId() const noexcept
Provides access to firmID field.
Definition Messages.h:6786
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::OrdersEntry::orderPriority
bool orderPriority(Uint64 &value) const noexcept
Provides access to orderPriority field.
Definition Messages.h:6716
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6923
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:6872
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:6902
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:6882
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::Orders
SbeGroup< OrdersEntry, GroupSizeEncoding, MessageSize > Orders
Repeating group containing OrdersEntry entries.
Definition Messages.h:6845
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:6949
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6935
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:6970
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::LongOrderUpdate
LongOrderUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:6861
OnixS::Euronext::MarketData::OptiqMdg::Messaging::LongOrderUpdate::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:6892
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::bookState
bool bookState(BookState::Enum &value) const noexcept
Provides access to bookState field.
Definition Messages.h:2589
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::tradingSide
bool tradingSide(TradingSide::Enum &value) const noexcept
Provides access to tradingSide field.
Definition Messages.h:2633
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:2737
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:2579
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::priceLimits
bool priceLimits(PriceLimits::Enum &value) const noexcept
Provides access to priceLimits field.
Definition Messages.h:2643
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::phaseQualifier
PhaseQualifier phaseQualifier() const noexcept
Provides access to phaseQualifier field.
Definition Messages.h:2611
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::session
Session::Enum session() const noexcept
Provides access to session field.
Definition Messages.h:2677
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::scheduledEventTime
bool scheduledEventTime(Uint64 &value) const noexcept
Provides access to scheduledEventTime field.
Definition Messages.h:2699
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:2569
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:2542
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::quoteSpreadMultiplier
bool quoteSpreadMultiplier(QuoteSpreadMultiplier::Enum &value) const noexcept
Provides access to quoteSpreadMultiplier field.
Definition Messages.h:2654
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:2723
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::orderEntryQualifier
bool orderEntryQualifier(OrderEntryQualifier::Enum &value) const noexcept
Provides access to orderEntryQualifier field.
Definition Messages.h:2666
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::scheduledEvent
bool scheduledEvent(ScheduledEvent::Enum &value) const noexcept
Provides access to scheduledEvent field.
Definition Messages.h:2688
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::instrumentState
bool instrumentState(InstrumentState::Enum &value) const noexcept
Provides access to instrumentState field.
Definition Messages.h:2710
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:2546
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::changeType
MarketDataChangeType::Enum changeType() const noexcept
Provides access to changeType field.
Definition Messages.h:2559
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::tradingPeriod
bool tradingPeriod(TradingPeriod::Enum &value) const noexcept
Provides access to tradingPeriod field.
Definition Messages.h:2622
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatesEntry::statusReason
bool statusReason(StatusReason::Enum &value) const noexcept
Provides access to statusReason field.
Definition Messages.h:2600
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:2829
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:2786
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:2796
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStates
SbeGroup< MarketStatesEntry, GroupSizeEncoding, MessageSize > MarketStates
Repeating group containing MarketStatesEntry entries.
Definition Messages.h:2759
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:2855
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:2841
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:2876
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::MarketStatusChange
MarketStatusChange(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:2775
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketStatusChange::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:2806
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::quantity
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition Messages.h:708
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:734
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:655
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::className
static constexpr const Char * className()
Entity class name.
Definition Messages.h:747
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::numberOfOrders
bool numberOfOrders(Uint16 &value) const noexcept
Provides access to numberOfOrders field.
Definition Messages.h:688
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::updateType
MarketDataUpdateType::Enum updateType() const noexcept
Provides access to updateType field.
Definition Messages.h:668
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:678
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::price
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition Messages.h:698
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:651
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::UpdatesEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:720
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::MarketUpdate
MarketUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:772
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:834
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:783
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:813
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:793
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::Updates
SbeGroup< UpdatesEntry, GroupSizeEncoding, MessageSize > Updates
Repeating group containing UpdatesEntry entries.
Definition Messages.h:756
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:860
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:846
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:881
OnixS::Euronext::MarketData::OptiqMdg::Messaging::MarketUpdate::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:803
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:1081
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::previousPriority
bool previousPriority(Uint64 &value) const noexcept
Provides access to previousPriority field.
Definition Messages.h:1005
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderPx
bool orderPx(Int64 &value) const noexcept
Provides access to orderPx field.
Definition Messages.h:1025
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderQuantity
bool orderQuantity(Uint64 &value) const noexcept
Provides access to orderQuantity field.
Definition Messages.h:1045
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::className
static constexpr const Char * className()
Entity class name.
Definition Messages.h:1094
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:962
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderSide
bool orderSide(OrderSide::Enum &value) const noexcept
Provides access to orderSide field.
Definition Messages.h:1035
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::pegOffset
bool pegOffset(Int8 &value) const noexcept
Provides access to pegOffset field.
Definition Messages.h:1055
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:974
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:958
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1067
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderType
bool orderType(OrderType::Enum &value) const noexcept
Provides access to orderType field.
Definition Messages.h:1015
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::actionType
MarketDataActionType::Enum actionType() const noexcept
Provides access to actionType field.
Definition Messages.h:985
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrdersEntry::orderPriority
bool orderPriority(Uint64 &value) const noexcept
Provides access to orderPriority field.
Definition Messages.h:995
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::OrderUpdate
OrderUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:1119
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:1181
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:1130
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:1160
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:1140
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::Orders
SbeGroup< OrdersEntry, GroupSizeEncoding, MessageSize > Orders
Repeating group containing OrdersEntry entries.
Definition Messages.h:1103
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:1207
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:1193
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:1228
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OrderUpdate::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:1150
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:6281
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightRepEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:6239
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:6243
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightRepEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:6267
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6552
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::lotMultiplier
bool lotMultiplier(Uint64 &value) const noexcept
Provides access to lotMultiplier field.
Definition Messages.h:6519
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:6330
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::derivativesInstrumentType
bool derivativesInstrumentType(DerivativesInstrumentType::Enum &value) const noexcept
Provides access to derivativesInstrumentType field.
Definition Messages.h:6465
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:6340
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::iSINCode
StrRef iSINCode() const noexcept
Provides access to iSINCode field.
Definition Messages.h:6380
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::maturityDate
StrRef maturityDate() const noexcept
Provides access to maturityDate field.
Definition Messages.h:6402
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::contractSymbolIndex
bool contractSymbolIndex(Uint32 &value) const noexcept
Provides access to contractSymbolIndex field.
Definition Messages.h:6360
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::derivativesInstrumentTradingCode
bool derivativesInstrumentTradingCode(StrRef &value) const noexcept
Provides access to derivativesInstrumentTradingCode field.
Definition Messages.h:6453
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::lastTradingDate
bool lastTradingDate(Uint16 &value) const noexcept
Provides access to lastTradingDate field.
Definition Messages.h:6433
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::daysToExpiry
bool daysToExpiry(Uint16 &value) const noexcept
Provides access to daysToExpiry field.
Definition Messages.h:6443
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::underlyingSymbolIndex
bool underlyingSymbolIndex(Uint32 &value) const noexcept
Provides access to underlyingSymbolIndex field.
Definition Messages.h:6499
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::underlyingDerivativesInstrumentTradingCode
bool underlyingDerivativesInstrumentTradingCode(StrRef &value) const noexcept
Provides access to underlyingDerivativesInstrumentTradingCode field.
Definition Messages.h:6488
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::cFI
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition Messages.h:6391
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::lotSize
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition Messages.h:6413
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::instrumentEventDate
bool instrumentEventDate(Uint16 &value) const noexcept
Provides access to instrumentEventDate field.
Definition Messages.h:6370
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::tradingUnit
bool tradingUnit(Uint64 &value) const noexcept
Provides access to tradingUnit field.
Definition Messages.h:6509
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:6350
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::expiryCycleType
bool expiryCycleType(ExpiryCycleType::Enum &value) const noexcept
Provides access to expiryCycleType field.
Definition Messages.h:6477
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::expirationDate
bool expirationDate(Uint16 &value) const noexcept
Provides access to expirationDate field.
Definition Messages.h:6530
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:6579
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6565
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:6600
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightRep
SbeGroup< OutrightRepEntry, GroupSizeEncoding, MessageSize > OutrightRep
Repeating group containing OutrightRepEntry entries.
Definition Messages.h:6303
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::strikePrice
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition Messages.h:6423
OnixS::Euronext::MarketData::OptiqMdg::Messaging::OutrightStandingData::OutrightStandingData
OutrightStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:6319
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::quantity
bool quantity(Uint64 &value) const noexcept
Provides access to quantity field.
Definition Messages.h:1352
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:1412
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::className
static constexpr const Char * className()
Entity class name.
Definition Messages.h:1425
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::imbalanceQty
bool imbalanceQty(Uint64 &value) const noexcept
Provides access to imbalanceQty field.
Definition Messages.h:1362
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:1332
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::price
bool price(Int64 &value) const noexcept
Provides access to price field.
Definition Messages.h:1342
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:1305
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1398
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::priceType
MarketDataPriceType::Enum priceType() const noexcept
Provides access to priceType field.
Definition Messages.h:1322
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::imbalanceQtySide
bool imbalanceQtySide(ImbalanceQuantitySide::Enum &value) const noexcept
Provides access to imbalanceQtySide field.
Definition Messages.h:1373
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PricesEntry::priceQualifier
bool priceQualifier(PriceQualifier::Enum &value) const noexcept
Provides access to priceQualifier field.
Definition Messages.h:1385
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:1309
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:1512
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:1461
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:1491
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:1471
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::Prices
SbeGroup< PricesEntry, GroupSizeEncoding, MessageSize > Prices
Repeating group containing PricesEntry entries.
Definition Messages.h:1434
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:1538
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:1524
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:1559
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::PriceUpdate
PriceUpdate(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:1450
OnixS::Euronext::MarketData::OptiqMdg::Messaging::PriceUpdate::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:1481
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::RealTimeIndex
RealTimeIndex(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4302
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4426
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:4313
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::eventTime
bool eventTime(Uint64 &value) const noexcept
Provides access to eventTime field.
Definition Messages.h:4343
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:4323
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::pctgOfCapitalization
bool pctgOfCapitalization(Uint64 &value) const noexcept
Provides access to pctgOfCapitalization field.
Definition Messages.h:4373
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::indexPriceCode
IndexPriceCode::Enum indexPriceCode() const noexcept
Provides access to indexPriceCode field.
Definition Messages.h:4413
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::indexLevelType
IndexLevelType::Enum indexLevelType() const noexcept
Provides access to indexLevelType field.
Definition Messages.h:4403
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::prctVarfromPrevClose
bool prctVarfromPrevClose(Int64 &value) const noexcept
Provides access to prctVarfromPrevClose field.
Definition Messages.h:4383
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:4353
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:4452
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4438
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::numTradedInstruments
bool numTradedInstruments(Uint16 &value) const noexcept
Provides access to numTradedInstruments field.
Definition Messages.h:4393
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4473
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:4333
OnixS::Euronext::MarketData::OptiqMdg::Messaging::RealTimeIndex::indexLevel
bool indexLevel(Int64 &value) const noexcept
Provides access to indexLevel field.
Definition Messages.h:4363
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:3323
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:3401
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::marketModel
bool marketModel(MarketModel::Enum &value) const noexcept
Provides access to marketModel field.
Definition Messages.h:3343
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::lotSize
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition Messages.h:3353
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:3297
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::instUnitExp
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition Messages.h:3364
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::anonymous
bool anonymous(Anonymous::Enum &value) const noexcept
Provides access to anonymous field.
Definition Messages.h:3375
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:3387
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:3301
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:3313
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRepEntry::tickSizeIndexId
bool tickSizeIndexId(Uint16 &value) const noexcept
Provides access to tickSizeIndexID field.
Definition Messages.h:3333
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::underlyingMIC
bool underlyingMIC(StrRef &value) const noexcept
Provides access to underlyingMIC field.
Definition Messages.h:3817
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::thresholdLISPostTrade60mn
bool thresholdLISPostTrade60mn(Uint64 &value) const noexcept
Provides access to thresholdLISPostTrade60mn field.
Definition Messages.h:4067
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::taxCode
bool taxCode(TaxCode::Enum &value) const noexcept
Provides access to taxCode field.
Definition Messages.h:3949
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4175
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::priceDecimals
bool priceDecimals(UnsignedChar &value) const noexcept
Provides access to priceDecimals field.
Definition Messages.h:3555
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:3450
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::guaranteeIndicator
bool guaranteeIndicator(GuaranteeIndicator::Enum &value) const noexcept
Provides access to guaranteeIndicator field.
Definition Messages.h:3699
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maxOrderAmountCall
bool maxOrderAmountCall(Uint64 &value) const noexcept
Provides access to maxOrderAmountCall field.
Definition Messages.h:4109
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::longMnemonic
bool longMnemonic(StrRef &value) const noexcept
Provides access to longMnemonic field.
Definition Messages.h:4097
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::strikeCurrencyIndicator
bool strikeCurrencyIndicator(StrikeCurrencyIndicator::Enum &value) const noexcept
Provides access to strikeCurrencyIndicator field.
Definition Messages.h:3873
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:3460
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::issuingCountry
bool issuingCountry(StrRef &value) const noexcept
Provides access to issuingCountry field.
Definition Messages.h:3721
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::iSINCode
StrRef iSINCode() const noexcept
Provides access to iSINCode field.
Definition Messages.h:3544
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::mnemonic
bool mnemonic(StrRef &value) const noexcept
Provides access to mnemonic field.
Definition Messages.h:3806
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::StandingData
StandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:3439
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::iCBCode
bool iCBCode(StrRef &value) const noexcept
Provides access to iCBCode field.
Definition Messages.h:4056
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::EmmPatternRep
SbeGroup< EmmPatternRepEntry, GroupSizeEncoding, MessageSize > EmmPatternRep
Repeating group containing EmmPatternRepEntry entries.
Definition Messages.h:3423
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::mIC
StrRef mIC() const noexcept
Provides access to mIC field.
Definition Messages.h:3773
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::ratioDecimals
bool ratioDecimals(UnsignedChar &value) const noexcept
Provides access to ratioDecimals field.
Definition Messages.h:3585
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::iCB
bool iCB(StrRef &value) const noexcept
Provides access to iCB field.
Definition Messages.h:3710
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::mainDepositary
bool mainDepositary(StrRef &value) const noexcept
Provides access to mainDepositary field.
Definition Messages.h:3677
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::cFI
StrRef cFI() const noexcept
Provides access to cFI field.
Definition Messages.h:3595
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::marketOfReferenceMIC
bool marketOfReferenceMIC(StrRef &value) const noexcept
Provides access to marketOfReferenceMIC field.
Definition Messages.h:4045
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::nominalCurrency
bool nominalCurrency(StrRef &value) const noexcept
Provides access to nominalCurrency field.
Definition Messages.h:4004
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maximumDecimalsInQuantity
bool maximumDecimalsInQuantity(UnsignedChar &value) const noexcept
Provides access to maximumDecimalsInQuantity field.
Definition Messages.h:3763
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::tradingCurrency
bool tradingCurrency(StrRef &value) const noexcept
Provides access to tradingCurrency field.
Definition Messages.h:3839
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::issuePriceDecimals
bool issuePriceDecimals(UnsignedChar &value) const noexcept
Provides access to issuePriceDecimals field.
Definition Messages.h:4015
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maturityDate
bool maturityDate(StrRef &value) const noexcept
Provides access to maturityDate field.
Definition Messages.h:3752
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::darkMinQuantity
bool darkMinQuantity(Uint32 &value) const noexcept
Provides access to darkMinQuantity field.
Definition Messages.h:3646
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::depositaryList
bool depositaryList(StrRef &value) const noexcept
Provides access to depositaryList field.
Definition Messages.h:3666
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::amountDecimals
bool amountDecimals(UnsignedChar &value) const noexcept
Provides access to amountDecimals field.
Definition Messages.h:3575
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::countryOfExchange
bool countryOfExchange(StrRef &value) const noexcept
Provides access to countryOfExchange field.
Definition Messages.h:3795
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::underlyingISINCode
bool underlyingISINCode(StrRef &value) const noexcept
Provides access to underlyingISINCode field.
Definition Messages.h:3828
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::lotSize
bool lotSize(Uint64 &value) const noexcept
Provides access to lotSize field.
Definition Messages.h:3742
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::issuePrice
bool issuePrice(Int64 &value) const noexcept
Provides access to issuePrice field.
Definition Messages.h:3994
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::thresholdLISPostTrade120mn
bool thresholdLISPostTrade120mn(Uint64 &value) const noexcept
Provides access to thresholdLISPostTrade120mn field.
Definition Messages.h:4077
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::darkLISThreshold
bool darkLISThreshold(Uint64 &value) const noexcept
Provides access to darkLISThreshold field.
Definition Messages.h:3636
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instrumentEventDate
bool instrumentEventDate(Uint16 &value) const noexcept
Provides access to instrumentEventDate field.
Definition Messages.h:3606
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:3470
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::quantityNotation
bool quantityNotation(StrRef &value) const noexcept
Provides access to quantityNotation field.
Definition Messages.h:3904
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::dateOfLastTrade
bool dateOfLastTrade(Uint16 &value) const noexcept
Provides access to dateOfLastTrade field.
Definition Messages.h:3656
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::typeOfCorporateEvent
bool typeOfCorporateEvent(StrRef &value) const noexcept
Provides access to typeOfCorporateEvent field.
Definition Messages.h:3959
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instUnitExp
bool instUnitExp(InstrumentUnitExpression::Enum &value) const noexcept
Provides access to instUnitExp field.
Definition Messages.h:3916
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::poolFactor
bool poolFactor(Uint32 &value) const noexcept
Provides access to poolFactor field.
Definition Messages.h:4153
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::optiqSegment
OptiqSegment::Enum optiqSegment() const noexcept
Provides access to optiqSegment field.
Definition Messages.h:3480
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:4204
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::settlementDelay
bool settlementDelay(StrRef &value) const noexcept
Provides access to settlementDelay field.
Definition Messages.h:3927
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::quantityDecimals
bool quantityDecimals(UnsignedChar &value) const noexcept
Provides access to quantityDecimals field.
Definition Messages.h:3565
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4190
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::typeOfMarketAdmission
bool typeOfMarketAdmission(TypeOfMarketAdmission::Enum &value) const noexcept
Provides access to typeOfMarketAdmission field.
Definition Messages.h:3971
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::thresholdLISPostTradeEOD
bool thresholdLISPostTradeEOD(Uint64 &value) const noexcept
Provides access to thresholdLISPostTradeEOD field.
Definition Messages.h:4087
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::strikeCurrency
bool strikeCurrency(StrRef &value) const noexcept
Provides access to strikeCurrency field.
Definition Messages.h:3938
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4225
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::liquidInstrumentIndicator
bool liquidInstrumentIndicator(UnsignedChar &value) const noexcept
Provides access to liquidInstrumentIndicator field.
Definition Messages.h:4035
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maxOrderAmountContinuous
bool maxOrderAmountContinuous(Uint64 &value) const noexcept
Provides access to maxOrderAmountContinuous field.
Definition Messages.h:4120
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maxOrderQuantityCall
bool maxOrderQuantityCall(Uint64 &value) const noexcept
Provides access to maxOrderQuantityCall field.
Definition Messages.h:4131
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::strikePriceDecimals
bool strikePriceDecimals(UnsignedChar &value) const noexcept
Provides access to strikePriceDecimals field.
Definition Messages.h:4025
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::repoIndicator
bool repoIndicator(RepoIndicator::Enum &value) const noexcept
Provides access to repoIndicator field.
Definition Messages.h:3983
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::tradingCurrencyIndicator
bool tradingCurrencyIndicator(TradingCurrencyIndicator::Enum &value) const noexcept
Provides access to tradingCurrencyIndicator field.
Definition Messages.h:3861
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::parValue
bool parValue(Uint64 &value) const noexcept
Provides access to parValue field.
Definition Messages.h:3894
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::maxOrderQuantityContinuous
bool maxOrderQuantityContinuous(Uint64 &value) const noexcept
Provides access to maxOrderQuantityContinuous field.
Definition Messages.h:4142
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:3626
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::lastAdjustedClosingPrice
bool lastAdjustedClosingPrice(Int64 &value) const noexcept
Provides access to lastAdjustedClosingPrice field.
Definition Messages.h:3732
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::partitionId
bool partitionId(Uint16 &value) const noexcept
Provides access to partitionID field.
Definition Messages.h:3490
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::strikePrice
bool strikePrice(Int64 &value) const noexcept
Provides access to strikePrice field.
Definition Messages.h:3616
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::numberInstrumentCirculating
bool numberInstrumentCirculating(Uint64 &value) const noexcept
Provides access to numberInstrumentCirculating field.
Definition Messages.h:3884
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::currencyCoefficient
bool currencyCoefficient(Uint32 &value) const noexcept
Provides access to currencyCoefficient field.
Definition Messages.h:3850
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instrumentName
StrRef instrumentName() const noexcept
Provides access to instrumentName field.
Definition Messages.h:3511
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::firstSettlementDate
bool firstSettlementDate(Uint16 &value) const noexcept
Provides access to firstSettlementDate field.
Definition Messages.h:3688
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::fullInstrumentName
bool fullInstrumentName(StrRef &value) const noexcept
Provides access to fullInstrumentName field.
Definition Messages.h:3500
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instrumentTradingCode
bool instrumentTradingCode(StrRef &value) const noexcept
Provides access to instrumentTradingCode field.
Definition Messages.h:3522
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::instrumentGroupCode
StrRef instrumentGroupCode() const noexcept
Provides access to instrumentGroupCode field.
Definition Messages.h:3533
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StandingData::mICList
bool mICList(StrRef &value) const noexcept
Provides access to mICList field.
Definition Messages.h:3784
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::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:139
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:9928
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::lastMDSeqNum
bool lastMDSeqNum(Uint64 &value) const noexcept
Provides access to lastMDSeqNum field.
Definition Messages.h:9905
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::StartOfSnapshot
StartOfSnapshot(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:9894
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::snapshotTime
bool snapshotTime(Uint64 &value) const noexcept
Provides access to snapshotTime field.
Definition Messages.h:9915
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:9954
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:9940
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StartOfSnapshot::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:9975
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:4582
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::className
static constexpr const Char * className()
Entity class name.
Definition Messages.h:4595
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::statsUpdateValue
bool statsUpdateValue(Int64 &value) const noexcept
Provides access to statsUpdateValue field.
Definition Messages.h:4556
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:4530
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:4568
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:4534
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStatsEntry::statsUpdateType
StatsUpdateType::Enum statsUpdateType() const noexcept
Provides access to statsUpdateType field.
Definition Messages.h:4546
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4672
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:4631
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:4641
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:4620
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:4651
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:4698
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4684
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::NewStats
SbeGroup< NewStatsEntry, GroupSizeEncoding, MessageSize > NewStats
Repeating group containing NewStatsEntry entries.
Definition Messages.h:4604
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Statistics::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4719
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::legSymbolIndex
bool legSymbolIndex(Uint32 &value) const noexcept
Provides access to legSymbolIndex field.
Definition Messages.h:5110
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::legBuySell
LegBuyorSell::Enum legBuySell() const noexcept
Provides access to legBuySell field.
Definition Messages.h:5140
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::legRatio
bool legRatio(Uint32 &value) const noexcept
Provides access to legRatio field.
Definition Messages.h:5130
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:5098
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1Entry::legPrice
bool legPrice(Int64 &value) const noexcept
Provides access to legPrice field.
Definition Messages.h:5120
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:5331
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:5215
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:5225
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::maturityDate
StrRef maturityDate() const noexcept
Provides access to maturityDate field.
Definition Messages.h:5276
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::contractSymbolIndex
bool contractSymbolIndex(Uint32 &value) const noexcept
Provides access to contractSymbolIndex field.
Definition Messages.h:5297
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::cFI
bool cFI(StrRef &value) const noexcept
Provides access to cFI field.
Definition Messages.h:5307
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:5245
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:5357
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::strategyStandingDatarep1
StrategyStandingDatarep1 strategyStandingDatarep1() const noexcept
Definition Messages.h:5318
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5343
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingDatarep1
SbeGroup< StrategyStandingDatarep1Entry, GroupSizeEncoding, MessageSize > StrategyStandingDatarep1
Repeating group containing StrategyStandingDatarep1Entry entries.
Definition Messages.h:5188
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:5378
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::derivativesInstrumentTradingCode
StrRef derivativesInstrumentTradingCode() const noexcept
Provides access to derivativesInstrumentTradingCode field.
Definition Messages.h:5255
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::eMM
Emm::Enum eMM() const noexcept
Provides access to eMM field.
Definition Messages.h:5235
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::exchangeCode
ExchangeCode::Enum exchangeCode() const noexcept
Provides access to exchangeCode field.
Definition Messages.h:5266
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::strategyCode
StrategyCode::Enum strategyCode() const noexcept
Provides access to strategyCode field.
Definition Messages.h:5287
OnixS::Euronext::MarketData::OptiqMdg::Messaging::StrategyStandingData::StrategyStandingData
StrategyStandingData(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:5204
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:547
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:483
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::retransmissionEndTime
bool retransmissionEndTime(Uint64 &value) const noexcept
Provides access to retransmissionEndTime field.
Definition Messages.h:524
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:504
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:534
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::retransmissionStartTime
bool retransmissionStartTime(Uint64 &value) const noexcept
Provides access to retransmissionStartTime field.
Definition Messages.h:514
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:573
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:559
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:594
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::TechnicalNotification
TechnicalNotification(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:472
OnixS::Euronext::MarketData::OptiqMdg::Messaging::TechnicalNotification::technicalNotificationType
TechnicalNotificationType::Enum technicalNotificationType() const noexcept
Provides access to technicalNotificationType field.
Definition Messages.h:494
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:3061
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::phaseTime
bool phaseTime(Uint64 &value) const noexcept
Provides access to phaseTime field.
Definition Messages.h:2971
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::className
static constexpr const Char * className()
Entity class name.
Definition Messages.h:3074
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::tradingPeriod
TradingPeriod::Enum tradingPeriod() const noexcept
Provides access to tradingPeriod field.
Definition Messages.h:3001
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::phaseQualifier
PhaseQualifier phaseQualifier() const noexcept
Provides access to phaseQualifier field.
Definition Messages.h:2991
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::session
Session::Enum session() const noexcept
Provides access to session field.
Definition Messages.h:3023
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:2955
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::phaseId
PhaseId::Enum phaseId() const noexcept
Provides access to phaseId field.
Definition Messages.h:2981
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:3047
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::orderEntryQualifier
bool orderEntryQualifier(OrderEntryQualifier::Enum &value) const noexcept
Provides access to orderEntryQualifier field.
Definition Messages.h:3012
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::TimetablesEntry::scheduledEvent
bool scheduledEvent(ScheduledEvent::Enum &value) const noexcept
Provides access to scheduledEvent field.
Definition Messages.h:3034
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:2959
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::patternId
bool patternId(Uint16 &value) const noexcept
Provides access to patternID field.
Definition Messages.h:3140
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:3173
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::eMM
bool eMM(Emm::Enum &value) const noexcept
Provides access to eMM field.
Definition Messages.h:3130
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::seqNum
bool seqNum(Uint64 &value) const noexcept
Provides access to mDSeqNum field.
Definition Messages.h:3110
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::rebroadcastIndicator
bool rebroadcastIndicator(UnsignedChar &value) const noexcept
Provides access to rebroadcastIndicator field.
Definition Messages.h:3120
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::symbolIndex
bool symbolIndex(Uint32 &value) const noexcept
Provides access to symbolIndex field.
Definition Messages.h:3150
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:3199
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:3185
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:3220
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::Timetable
Timetable()=default
Initializes a blank instance.
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::Timetables
SbeGroup< TimetablesEntry, GroupSizeEncoding, MessageSize > Timetables
Repeating group containing TimetablesEntry entries.
Definition Messages.h:3083
OnixS::Euronext::MarketData::OptiqMdg::Messaging::Timetable::Timetable
Timetable(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:3099