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