OnixS C++ B3 Binary UMDF Market Data Handler 1.10.0
Users' manual and 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/B3/MarketData/UMDF/ABI.h>
27#include <OnixS/B3/MarketData/UMDF/messaging/Composites.h>
28#include <OnixS/B3/MarketData/UMDF/messaging/SbeMessage.h>
29#include <OnixS/B3/MarketData/UMDF/messaging/Forwards.h>
30
31#ifdef DELETE
32#undef DELETE
33#endif
34
35ONIXS_B3_UMDF_MD_MESSAGING_NAMESPACE_BEGIN
36
38ONIXS_B3_UMDF_MD_LTWT_STRUCT
39SequenceReset_1
40: SbeMessage
41{
43 typedef SchemaTraits Schema;
44
46 enum { TemplateId = 1 };
47
49 SequenceReset_1() = default;
50
52 SequenceReset_1(
53 void* data,
54 EncodedLength length,
55 NoInit)
56 : SbeMessage(data, length)
57 {
58 checkCompatibility();
59 }
60
62 explicit
63 SequenceReset_1(
64 const SbeMessage& message)
65 : SbeMessage(message)
66 {
67 assert(message.valid());
68
69 checkCompatibility();
70 }
71
74 SequenceReset_1(
75 void* data,
76 EncodedLength length,
77 NoInit,
78 NoCheck)
79 noexcept
80 : SbeMessage(data, length, NoCheck())
81 {
82 assert(schemaId() == Schema::Id);
83 assert(version() >= Schema::MinimalVersion);
84 assert(TemplateId == templateId());
85 }
86
88 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
89 constexpr
95
98 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
99 constexpr
100 static ApplVerID::Enum applVerId()
101 noexcept
102 {
103 return ApplVerID::FIX50SP2;
104 }
105
107 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
108 constexpr
109 static SeqNum1 newSeqNo()
110 noexcept
111 {
112 return SeqNum1();
113 }
114
116 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
117 constexpr
118 static
119 BlockLength
120 minimalBlockLength(
121 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
122 noexcept
123 {
124 return
125 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
126 0;
127 }
128
130 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
131 constexpr
139
141 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
142 ONIXS_B3_UMDF_MD_NODISCARD
143 constexpr
144 static
145 MessageSize
146 getMinimalVariableFieldsSize(
147 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
148 {
149 return
150 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
151 0;
152 }
153
155 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
156 ONIXS_B3_UMDF_MD_NODISCARD
157 constexpr
158 static StrRef className()
159 noexcept
160 {
161 return constructStrRef("SequenceReset_1");
162 }
163
165 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
166 ONIXS_B3_UMDF_MD_NODISCARD
167 constexpr
168 static StrRef fixType()
169 noexcept
170 {
171 return constructStrRef("4");
172 }
173
175 ONIXS_B3_UMDF_MD_NODISCARD
176 std::string toString() const;
177
178private:
179 void checkLength(
180 EncodedLength length, SchemaVersion version) const
181 {
182 const EncodedLength minimalRequiredLength =
183 minimalBlockLength(version) +
184 MessageHeader::Size +
185 getMinimalVariableFieldsSize(version);
186
187 checkBinaryLength(
188 *this, length, minimalRequiredLength);
189 }
190
191 void checkCompatibility() const
192 {
193 assert(TemplateId == templateId());
194
195 checkSchema<Schema>(schemaId(), version());
196 checkLength(bufferSize(), version());
197 }
198};
199
201ONIXS_B3_UMDF_MD_LTWT_STRUCT
202Sequence_2
203: SbeMessage
204{
206 typedef SchemaTraits Schema;
207
209 enum { TemplateId = 2 };
210
212 Sequence_2() = default;
213
215 Sequence_2(
216 void* data,
217 EncodedLength length,
218 NoInit)
219 : SbeMessage(data, length)
220 {
221 checkCompatibility();
222 }
223
225 explicit
226 Sequence_2(
227 const SbeMessage& message)
228 : SbeMessage(message)
229 {
230 assert(message.valid());
231
232 checkCompatibility();
233 }
234
237 Sequence_2(
238 void* data,
239 EncodedLength length,
240 NoInit,
241 NoCheck)
242 noexcept
243 : SbeMessage(data, length, NoCheck())
244 {
245 assert(schemaId() == Schema::Id);
246 assert(version() >= Schema::MinimalVersion);
247 assert(TemplateId == templateId());
248 }
249
251 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
252 constexpr
253 static MessageType::Enum messageType()
254 noexcept
255 {
256 return MessageType::Sequence;
257 }
258
261 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
262 constexpr
263 static ApplVerID::Enum applVerId()
264 noexcept
265 {
266 return ApplVerID::FIX50SP2;
267 }
268
271 ONIXS_B3_UMDF_MD_NODISCARD
272 SeqNum nextSeqNo() const
273 noexcept
274 {
275 constexpr BlockLength offset = 0;
276
277 return ordinary<SeqNum>(offset);
278 }
279
281 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
282 constexpr
283 static
284 BlockLength
285 minimalBlockLength(
286 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
287 noexcept
288 {
289 return
290 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
291 4;
292 }
293
295 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
296 constexpr
304
306 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
307 ONIXS_B3_UMDF_MD_NODISCARD
308 constexpr
309 static
310 MessageSize
311 getMinimalVariableFieldsSize(
312 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
313 {
314 return
315 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
316 0;
317 }
318
320 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
321 ONIXS_B3_UMDF_MD_NODISCARD
322 constexpr
323 static StrRef className()
324 noexcept
325 {
326 return constructStrRef("Sequence_2");
327 }
328
330 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
331 ONIXS_B3_UMDF_MD_NODISCARD
332 constexpr
333 static StrRef fixType()
334 noexcept
335 {
336 return constructStrRef("0");
337 }
338
340 ONIXS_B3_UMDF_MD_NODISCARD
341 std::string toString() const;
342
343private:
344 void checkLength(
345 EncodedLength length, SchemaVersion version) const
346 {
347 const EncodedLength minimalRequiredLength =
348 minimalBlockLength(version) +
349 MessageHeader::Size +
350 getMinimalVariableFieldsSize(version);
351
352 checkBinaryLength(
353 *this, length, minimalRequiredLength);
354 }
355
356 void checkCompatibility() const
357 {
358 assert(TemplateId == templateId());
359
360 checkSchema<Schema>(schemaId(), version());
361 checkLength(bufferSize(), version());
362 }
363};
364
366ONIXS_B3_UMDF_MD_LTWT_STRUCT
367EmptyBook_9
368: SbeMessage
369{
371 typedef SchemaTraits Schema;
372
374 enum { TemplateId = 9 };
375
377 EmptyBook_9() = default;
378
380 EmptyBook_9(
381 void* data,
382 EncodedLength length,
383 NoInit)
384 : SbeMessage(data, length)
385 {
386 checkCompatibility();
387 }
388
390 explicit
391 EmptyBook_9(
392 const SbeMessage& message)
393 : SbeMessage(message)
394 {
395 assert(message.valid());
396
397 checkCompatibility();
398 }
399
402 EmptyBook_9(
403 void* data,
404 EncodedLength length,
405 NoInit,
406 NoCheck)
407 noexcept
408 : SbeMessage(data, length, NoCheck())
409 {
410 assert(schemaId() == Schema::Id);
411 assert(version() >= Schema::MinimalVersion);
412 assert(TemplateId == templateId());
413 }
414
416 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
417 constexpr
423
426 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
427 constexpr
428 static ApplVerID::Enum applVerId()
429 noexcept
430 {
431 return ApplVerID::FIX50SP2;
432 }
433
435 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
436 constexpr
437 static UpdateAction::Enum mDUpdateAction()
438 noexcept
439 {
440 return UpdateAction::NEW;
441 }
442
444 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
445 constexpr
446 static EntryType::Enum mDEntryType()
447 noexcept
448 {
449 return EntryType::EMPTY_BOOK;
450 }
451
454 ONIXS_B3_UMDF_MD_NODISCARD
455 SecurityID securityId() const
456 noexcept
457 {
458 constexpr BlockLength offset = 0;
459
460 return ordinary<SecurityID>(offset);
461 }
462
464 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
465 constexpr
471
473 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
474 ONIXS_B3_UMDF_MD_NODISCARD
475 constexpr
476 static StrRef securityExchange()
477 noexcept
478 {
479 return constructStrRef("BVMF");
480 }
481
485 ONIXS_B3_UMDF_MD_NODISCARD
486 MatchEventIndicator matchEventIndicator() const
487 noexcept
488 {
489 constexpr BlockLength offset = 8;
490
491 return ordinary<MatchEventIndicator>(offset);
492 }
493
495 ONIXS_B3_UMDF_MD_NODISCARD
496 bool mDEntryTimestamp(UTCTimestampNanos& value) const
497 noexcept
498 {
499 constexpr BlockLength offset = 12;
500
501 return ordinary(value, offset, NullUTCTimestampNanos());
502 }
503
505 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
506 constexpr
507 static
508 BlockLength
509 minimalBlockLength(
510 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
511 noexcept
512 {
513 return
514 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
515 20;
516 }
517
519 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
520 constexpr
521 static
522 BlockLength
523 blockLength(
524 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
525 noexcept
526 {
527 return
528 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
529 minimalBlockLength(version);
530 }
531
533 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
534 ONIXS_B3_UMDF_MD_NODISCARD
535 constexpr
536 static
537 MessageSize
538 getMinimalVariableFieldsSize(
539 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
540 {
541 return
542 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
543 0;
544 }
545
547 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
548 ONIXS_B3_UMDF_MD_NODISCARD
549 constexpr
550 static StrRef className()
551 noexcept
552 {
553 return constructStrRef("EmptyBook_9");
554 }
555
557 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
558 ONIXS_B3_UMDF_MD_NODISCARD
559 constexpr
560 static StrRef fixType()
561 noexcept
562 {
563 return constructStrRef("EmptyBook_9");
564 }
565
567 ONIXS_B3_UMDF_MD_NODISCARD
568 std::string toString() const;
569
570private:
571 void checkLength(
572 EncodedLength length, SchemaVersion version) const
573 {
574 const EncodedLength minimalRequiredLength =
575 minimalBlockLength(version) +
576 MessageHeader::Size +
577 getMinimalVariableFieldsSize(version);
578
579 checkBinaryLength(
580 *this, length, minimalRequiredLength);
581 }
582
583 void checkCompatibility() const
584 {
585 assert(TemplateId == templateId());
586
587 checkSchema<Schema>(schemaId(), version());
588 checkLength(bufferSize(), version());
589 }
590};
591
593ONIXS_B3_UMDF_MD_LTWT_STRUCT
594ChannelReset_11
595: SbeMessage
596{
598 typedef SchemaTraits Schema;
599
601 enum { TemplateId = 11 };
602
604 ChannelReset_11() = default;
605
607 ChannelReset_11(
608 void* data,
609 EncodedLength length,
610 NoInit)
611 : SbeMessage(data, length)
612 {
613 checkCompatibility();
614 }
615
617 explicit
618 ChannelReset_11(
619 const SbeMessage& message)
620 : SbeMessage(message)
621 {
622 assert(message.valid());
623
624 checkCompatibility();
625 }
626
629 ChannelReset_11(
630 void* data,
631 EncodedLength length,
632 NoInit,
633 NoCheck)
634 noexcept
635 : SbeMessage(data, length, NoCheck())
636 {
637 assert(schemaId() == Schema::Id);
638 assert(version() >= Schema::MinimalVersion);
639 assert(TemplateId == templateId());
640 }
641
643 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
644 constexpr
650
653 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
654 constexpr
655 static ApplVerID::Enum applVerId()
656 noexcept
657 {
658 return ApplVerID::FIX50SP2;
659 }
660
662 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
663 constexpr
664 static UpdateAction::Enum mDUpdateAction()
665 noexcept
666 {
667 return UpdateAction::NEW;
668 }
669
671 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
672 constexpr
673 static EntryType::Enum mDEntryType()
674 noexcept
675 {
676 return EntryType::EMPTY_BOOK;
677 }
678
682 ONIXS_B3_UMDF_MD_NODISCARD
683 MatchEventIndicator matchEventIndicator() const
684 noexcept
685 {
686 constexpr BlockLength offset = 0;
687
688 return ordinary<MatchEventIndicator>(offset);
689 }
690
692 ONIXS_B3_UMDF_MD_NODISCARD
693 bool mDEntryTimestamp(UTCTimestampNanos& value) const
694 noexcept
695 {
696 constexpr BlockLength offset = 4;
697
698 return ordinary(value, offset, NullUTCTimestampNanos());
699 }
700
702 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
703 constexpr
704 static
705 BlockLength
706 minimalBlockLength(
707 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
708 noexcept
709 {
710 return
711 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
712 12;
713 }
714
716 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
717 constexpr
718 static
719 BlockLength
720 blockLength(
721 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
722 noexcept
723 {
724 return
725 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
726 minimalBlockLength(version);
727 }
728
730 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
731 ONIXS_B3_UMDF_MD_NODISCARD
732 constexpr
733 static
734 MessageSize
735 getMinimalVariableFieldsSize(
736 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
737 {
738 return
739 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
740 0;
741 }
742
744 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
745 ONIXS_B3_UMDF_MD_NODISCARD
746 constexpr
747 static StrRef className()
748 noexcept
749 {
750 return constructStrRef("ChannelReset_11");
751 }
752
754 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
755 ONIXS_B3_UMDF_MD_NODISCARD
756 constexpr
757 static StrRef fixType()
758 noexcept
759 {
760 return constructStrRef("ChannelReset_11");
761 }
762
764 ONIXS_B3_UMDF_MD_NODISCARD
765 std::string toString() const;
766
767private:
768 void checkLength(
769 EncodedLength length, SchemaVersion version) const
770 {
771 const EncodedLength minimalRequiredLength =
772 minimalBlockLength(version) +
773 MessageHeader::Size +
774 getMinimalVariableFieldsSize(version);
775
776 checkBinaryLength(
777 *this, length, minimalRequiredLength);
778 }
779
780 void checkCompatibility() const
781 {
782 assert(TemplateId == templateId());
783
784 checkSchema<Schema>(schemaId(), version());
785 checkLength(bufferSize(), version());
786 }
787};
788
790ONIXS_B3_UMDF_MD_LTWT_STRUCT
791SecurityStatus_3
792: SbeMessage
793{
795 typedef SchemaTraits Schema;
796
798 enum { TemplateId = 3 };
799
801 SecurityStatus_3() = default;
802
804 SecurityStatus_3(
805 void* data,
806 EncodedLength length,
807 NoInit)
808 : SbeMessage(data, length)
809 {
810 checkCompatibility();
811 }
812
814 explicit
815 SecurityStatus_3(
816 const SbeMessage& message)
817 : SbeMessage(message)
818 {
819 assert(message.valid());
820
821 checkCompatibility();
822 }
823
826 SecurityStatus_3(
827 void* data,
828 EncodedLength length,
829 NoInit,
830 NoCheck)
831 noexcept
832 : SbeMessage(data, length, NoCheck())
833 {
834 assert(schemaId() == Schema::Id);
835 assert(version() >= Schema::MinimalVersion);
836 assert(TemplateId == templateId());
837 }
838
840 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
841 constexpr
847
850 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
851 constexpr
852 static ApplVerID::Enum applVerId()
853 noexcept
854 {
855 return ApplVerID::FIX50SP2;
856 }
857
860 ONIXS_B3_UMDF_MD_NODISCARD
861 SecurityID securityId() const
862 noexcept
863 {
864 constexpr BlockLength offset = 0;
865
866 return ordinary<SecurityID>(offset);
867 }
868
870 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
871 constexpr
877
879 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
880 ONIXS_B3_UMDF_MD_NODISCARD
881 constexpr
882 static StrRef securityExchange()
883 noexcept
884 {
885 return constructStrRef("BVMF");
886 }
887
890 ONIXS_B3_UMDF_MD_NODISCARD
891 MatchEventIndicator matchEventIndicator() const
892 noexcept
893 {
894 constexpr BlockLength offset = 8;
895
896 return ordinary<MatchEventIndicator>(offset);
897 }
898
900 ONIXS_B3_UMDF_MD_NODISCARD
901 TradingSessionID::Enum tradingSessionId() const
902 noexcept
903 {
904 constexpr BlockLength offset = 9;
905
906 return enumeration<TradingSessionID>(offset);
907 }
908
910 ONIXS_B3_UMDF_MD_NODISCARD
911 SecurityTradingStatus::Enum
912 securityTradingStatus() const
913 noexcept
914 {
915 constexpr BlockLength offset = 10;
916
917 return enumeration<SecurityTradingStatus>(offset);
918 }
919
925 ONIXS_B3_UMDF_MD_NODISCARD
926 bool
927 securityTradingEvent(
928 SecurityTradingEvent::Enum& value) const
929 noexcept
930 {
931 constexpr BlockLength offset = 11;
932
933 return enumeration<SecurityTradingEvent>(value, offset, NullUInt8());
934 }
935
938 ONIXS_B3_UMDF_MD_NODISCARD
939 Timestamp tradeDate() const
940 noexcept
941 {
942 constexpr BlockLength offset = 12;
943
944 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
945 }
946
949 ONIXS_B3_UMDF_MD_NODISCARD
950 bool tradSesOpenTime(UTCTimestampNanos& value) const
951 noexcept
952 {
953 constexpr BlockLength offset = 16;
954
955 return ordinary(value, offset, NullUTCTimestampNanos());
956 }
957
959 ONIXS_B3_UMDF_MD_NODISCARD
960 bool transactTime(UTCTimestampNanos& value) const
961 noexcept
962 {
963 constexpr BlockLength offset = 24;
964
965 return ordinary(value, offset, NullUTCTimestampNanos());
966 }
967
970 ONIXS_B3_UMDF_MD_NODISCARD
971 bool rptSeq(RptSeq& value) const
972 noexcept
973 {
974 constexpr BlockLength offset = 32;
975
976 return ordinary(value, offset, NullRptSeq());
977 }
978
980 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
981 constexpr
982 static
983 BlockLength
984 minimalBlockLength(
985 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
986 noexcept
987 {
988 return
989 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
990 36;
991 }
992
994 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
995 constexpr
996 static
997 BlockLength
998 blockLength(
999 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
1000 noexcept
1001 {
1002 return
1003 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1004 minimalBlockLength(version);
1005 }
1006
1008 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1009 ONIXS_B3_UMDF_MD_NODISCARD
1010 constexpr
1011 static
1012 MessageSize
1013 getMinimalVariableFieldsSize(
1014 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
1015 {
1016 return
1017 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1018 0;
1019 }
1020
1022 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1023 ONIXS_B3_UMDF_MD_NODISCARD
1024 constexpr
1025 static StrRef className()
1026 noexcept
1027 {
1028 return constructStrRef("SecurityStatus_3");
1029 }
1030
1032 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1033 ONIXS_B3_UMDF_MD_NODISCARD
1034 constexpr
1035 static StrRef fixType()
1036 noexcept
1037 {
1038 return constructStrRef("SecurityStatus_3");
1039 }
1040
1042 ONIXS_B3_UMDF_MD_NODISCARD
1043 std::string toString() const;
1044
1045private:
1046 void checkLength(
1047 EncodedLength length, SchemaVersion version) const
1048 {
1049 const EncodedLength minimalRequiredLength =
1050 minimalBlockLength(version) +
1051 MessageHeader::Size +
1052 getMinimalVariableFieldsSize(version);
1053
1054 checkBinaryLength(
1055 *this, length, minimalRequiredLength);
1056 }
1057
1058 void checkCompatibility() const
1059 {
1060 assert(TemplateId == templateId());
1061
1062 checkSchema<Schema>(schemaId(), version());
1063 checkLength(bufferSize(), version());
1064 }
1065};
1066
1068ONIXS_B3_UMDF_MD_LTWT_STRUCT
1069SecurityGroupPhase_10
1070: SbeMessage
1071{
1073 typedef SchemaTraits Schema;
1074
1076 enum { TemplateId = 10 };
1077
1079 SecurityGroupPhase_10() = default;
1080
1082 SecurityGroupPhase_10(
1083 void* data,
1084 EncodedLength length,
1085 NoInit)
1086 : SbeMessage(data, length)
1087 {
1088 checkCompatibility();
1089 }
1090
1092 explicit
1093 SecurityGroupPhase_10(
1094 const SbeMessage& message)
1095 : SbeMessage(message)
1096 {
1097 assert(message.valid());
1098
1099 checkCompatibility();
1100 }
1101
1104 SecurityGroupPhase_10(
1105 void* data,
1106 EncodedLength length,
1107 NoInit,
1108 NoCheck)
1109 noexcept
1110 : SbeMessage(data, length, NoCheck())
1111 {
1112 assert(schemaId() == Schema::Id);
1113 assert(version() >= Schema::MinimalVersion);
1114 assert(TemplateId == templateId());
1115 }
1116
1118 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1119 constexpr
1120 static MessageType::Enum messageType()
1121 noexcept
1122 {
1123 return MessageType::SecurityStatus;
1124 }
1125
1128 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1129 constexpr
1130 static ApplVerID::Enum applVerId()
1131 noexcept
1132 {
1133 return ApplVerID::FIX50SP2;
1134 }
1135
1137 ONIXS_B3_UMDF_MD_NODISCARD
1138 StrRef securityGroup() const
1139 noexcept
1140 {
1141 constexpr BlockLength offset = 0;
1142 constexpr BlockLength length = 3;
1143
1144 return fixedStr<length>(offset);
1145 }
1146
1149 ONIXS_B3_UMDF_MD_NODISCARD
1150 MatchEventIndicator matchEventIndicator() const
1151 noexcept
1152 {
1153 constexpr BlockLength offset = 8;
1154
1155 return ordinary<MatchEventIndicator>(offset);
1156 }
1157
1159 ONIXS_B3_UMDF_MD_NODISCARD
1160 TradingSessionID::Enum tradingSessionId() const
1161 noexcept
1162 {
1163 constexpr BlockLength offset = 9;
1164
1165 return enumeration<TradingSessionID>(offset);
1166 }
1167
1169 ONIXS_B3_UMDF_MD_NODISCARD
1170 TradingSessionSubID::Enum
1171 tradingSessionSubId() const
1172 noexcept
1173 {
1174 constexpr BlockLength offset = 10;
1175
1176 return enumeration<TradingSessionSubID>(offset);
1177 }
1178
1181 ONIXS_B3_UMDF_MD_NODISCARD
1182 bool
1183 securityTradingEvent(
1184 SecurityTradingEvent::Enum& value) const
1185 noexcept
1186 {
1187 constexpr BlockLength offset = 11;
1188
1189 return enumeration<SecurityTradingEvent>(value, offset, NullUInt8());
1190 }
1191
1194 ONIXS_B3_UMDF_MD_NODISCARD
1195 Timestamp tradeDate() const
1196 noexcept
1197 {
1198 constexpr BlockLength offset = 12;
1199
1200 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
1201 }
1202
1205 ONIXS_B3_UMDF_MD_NODISCARD
1206 bool tradSesOpenTime(UTCTimestampNanos& value) const
1207 noexcept
1208 {
1209 constexpr BlockLength offset = 16;
1210
1211 return ordinary(value, offset, NullUTCTimestampNanos());
1212 }
1213
1215 ONIXS_B3_UMDF_MD_NODISCARD
1216 bool transactTime(UTCTimestampNanos& value) const
1217 noexcept
1218 {
1219 constexpr BlockLength offset = 24;
1220
1221 return ordinary(value, offset, NullUTCTimestampNanos());
1222 }
1223
1225 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1226 constexpr
1227 static
1228 BlockLength
1229 minimalBlockLength(
1230 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
1231 noexcept
1232 {
1233 return
1234 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1235 32;
1236 }
1237
1239 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1240 constexpr
1241 static
1242 BlockLength
1243 blockLength(
1244 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
1245 noexcept
1246 {
1247 return
1248 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1249 minimalBlockLength(version);
1250 }
1251
1253 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1254 ONIXS_B3_UMDF_MD_NODISCARD
1255 constexpr
1256 static
1257 MessageSize
1258 getMinimalVariableFieldsSize(
1259 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
1260 {
1261 return
1262 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1263 0;
1264 }
1265
1267 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1268 ONIXS_B3_UMDF_MD_NODISCARD
1269 constexpr
1270 static StrRef className()
1271 noexcept
1272 {
1273 return constructStrRef("SecurityGroupPhase_10");
1274 }
1275
1277 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1278 ONIXS_B3_UMDF_MD_NODISCARD
1279 constexpr
1280 static StrRef fixType()
1281 noexcept
1282 {
1283 return constructStrRef("SecurityGroupPhase_10");
1284 }
1285
1287 ONIXS_B3_UMDF_MD_NODISCARD
1288 std::string toString() const;
1289
1290private:
1291 void checkLength(
1292 EncodedLength length, SchemaVersion version) const
1293 {
1294 const EncodedLength minimalRequiredLength =
1295 minimalBlockLength(version) +
1296 MessageHeader::Size +
1297 getMinimalVariableFieldsSize(version);
1298
1299 checkBinaryLength(
1300 *this, length, minimalRequiredLength);
1301 }
1302
1303 void checkCompatibility() const
1304 {
1305 assert(TemplateId == templateId());
1306
1307 checkSchema<Schema>(schemaId(), version());
1308 checkLength(bufferSize(), version());
1309 }
1310};
1311
1313ONIXS_B3_UMDF_MD_LTWT_STRUCT
1314SecurityDefinition_12
1315: SbeMessage
1316{
1318 typedef SchemaTraits Schema;
1319
1321 enum { TemplateId = 12 };
1322
1325 ONIXS_B3_UMDF_MD_LTWT_STRUCT
1326 UnderlyingsEntry : SbeGroupEntry
1327 <
1328 GroupSizeEncoding::BlockLength
1329 >
1330 {
1332 typedef
1333 SbeGroupEntry
1334 <
1335 GroupSizeEncoding::BlockLength
1336 >
1337 Base;
1338
1341 UnderlyingsEntry(
1342 const void* data,
1343 EncodedLength length,
1344 SchemaVersion version)
1345 : Base(data, numericCast<Base::BlockLength>(length), version)
1346 {
1347 assert(version >= Schema::MinimalVersion);
1348 assert(length >= minimalBlockLength(version));
1349 }
1350
1352 ONIXS_B3_UMDF_MD_NODISCARD
1353 SecurityID underlyingSecurityId() const
1354 noexcept
1355 {
1356 constexpr BlockLength offset = 0;
1357
1358 return ordinary<SecurityID>(offset);
1359 }
1360
1363 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1364 constexpr
1370
1372 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1373 ONIXS_B3_UMDF_MD_NODISCARD
1374 constexpr
1375 static StrRef underlyingSecurityExchange()
1376 noexcept
1377 {
1378 return constructStrRef("BVMF");
1379 }
1380
1382 ONIXS_B3_UMDF_MD_NODISCARD
1383 StrRef underlyingSymbol() const
1384 noexcept
1385 {
1386 constexpr BlockLength offset = 8;
1387 constexpr BlockLength length = 20;
1388
1389 return fixedStr<length>(offset);
1390 }
1391
1394 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1395 constexpr
1403
1406 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1407 constexpr
1408 static
1409 BlockLength
1410 minimalBlockLength(
1411 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
1412 noexcept
1413 {
1414 return
1415 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1416 28;
1417 }
1418
1420 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1421 ONIXS_B3_UMDF_MD_NODISCARD
1422 constexpr
1423 static StrRef className()
1424 noexcept
1425 {
1426 return constructStrRef("SecurityDefinition_12.UnderlyingsEntry");
1427 }
1428 };
1429
1431 typedef
1432 SbeGroup<UnderlyingsEntry, GroupSizeEncoding, MessageSize>
1433 Underlyings;
1434
1437 ONIXS_B3_UMDF_MD_LTWT_STRUCT
1438 LegsEntry : SbeGroupEntry
1439 <
1440 GroupSizeEncoding::BlockLength
1441 >
1442 {
1444 typedef
1445 SbeGroupEntry
1446 <
1447 GroupSizeEncoding::BlockLength
1448 >
1449 Base;
1450
1453 LegsEntry(
1454 const void* data,
1455 EncodedLength length,
1456 SchemaVersion version)
1457 : Base(data, numericCast<Base::BlockLength>(length), version)
1458 {
1459 assert(version >= Schema::MinimalVersion);
1460 assert(length >= minimalBlockLength(version));
1461 }
1462
1464 ONIXS_B3_UMDF_MD_NODISCARD
1465 SecurityID legSecurityId() const
1466 noexcept
1467 {
1468 constexpr BlockLength offset = 0;
1469
1470 return ordinary<SecurityID>(offset);
1471 }
1472
1475 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1476 constexpr
1482
1484 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1485 ONIXS_B3_UMDF_MD_NODISCARD
1486 constexpr
1487 static StrRef legSecurityExchange()
1488 noexcept
1489 {
1490 return constructStrRef("BVMF");
1491 }
1492
1495 ONIXS_B3_UMDF_MD_NODISCARD
1496 bool legRatioQty(RatioQty& value) const
1497 noexcept
1498 {
1499 constexpr BlockLength offset = 8;
1500
1501 return decimal(value, offset, NullRatioQty());
1502 }
1503
1505 ONIXS_B3_UMDF_MD_NODISCARD
1506 SecurityType::Enum legSecurityType() const
1507 noexcept
1508 {
1509 constexpr BlockLength offset = 16;
1510
1511 return enumeration<SecurityType>(offset);
1512 }
1513
1515 ONIXS_B3_UMDF_MD_NODISCARD
1516 Side::Enum legSide() const
1517 noexcept
1518 {
1519 constexpr BlockLength offset = 17;
1520
1521 return enumeration<Side>(offset);
1522 }
1523
1525 ONIXS_B3_UMDF_MD_NODISCARD
1526 StrRef legSymbol() const
1527 noexcept
1528 {
1529 constexpr BlockLength offset = 18;
1530 constexpr BlockLength length = 20;
1531
1532 return fixedStr<length>(offset);
1533 }
1534
1537 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1538 constexpr
1539 static BlockLength blockLength(SchemaVersion version)
1540 noexcept
1541 {
1542 return
1543 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1544 minimalBlockLength(version);
1545 }
1546
1549 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1550 constexpr
1551 static
1552 BlockLength
1553 minimalBlockLength(
1554 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
1555 noexcept
1556 {
1557 return
1558 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1559 38;
1560 }
1561
1563 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1564 ONIXS_B3_UMDF_MD_NODISCARD
1565 constexpr
1566 static StrRef className()
1567 noexcept
1568 {
1569 return constructStrRef("SecurityDefinition_12.LegsEntry");
1570 }
1571 };
1572
1574 typedef
1575 SbeGroup<LegsEntry, GroupSizeEncoding, MessageSize>
1576 Legs;
1577
1581 ONIXS_B3_UMDF_MD_LTWT_STRUCT
1582 InstrAttribsEntry : SbeGroupEntry
1583 <
1584 GroupSizeEncoding::BlockLength
1585 >
1586 {
1588 typedef
1589 SbeGroupEntry
1590 <
1591 GroupSizeEncoding::BlockLength
1592 >
1593 Base;
1594
1597 InstrAttribsEntry(
1598 const void* data,
1599 EncodedLength length,
1600 SchemaVersion version)
1601 : Base(data, numericCast<Base::BlockLength>(length), version)
1602 {
1603 assert(version >= Schema::MinimalVersion);
1604 assert(length >= minimalBlockLength(version));
1605 }
1606
1608 ONIXS_B3_UMDF_MD_NODISCARD
1609 InstrAttribType::Enum instrAttribType() const
1610 noexcept
1611 {
1612 constexpr BlockLength offset = 0;
1613
1614 return enumeration<InstrAttribType>(offset);
1615 }
1616
1619 ONIXS_B3_UMDF_MD_NODISCARD
1620 InstrAttribValue::Enum instrAttribValue() const
1621 noexcept
1622 {
1623 constexpr BlockLength offset = 1;
1624
1625 return enumeration<InstrAttribValue>(offset);
1626 }
1627
1630 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1631 constexpr
1632 static BlockLength blockLength(SchemaVersion version)
1633 noexcept
1634 {
1635 return
1636 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1637 minimalBlockLength(version);
1638 }
1639
1642 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1643 constexpr
1644 static
1645 BlockLength
1646 minimalBlockLength(
1647 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
1648 noexcept
1649 {
1650 return
1651 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1652 2;
1653 }
1654
1656 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1657 ONIXS_B3_UMDF_MD_NODISCARD
1658 constexpr
1659 static StrRef className()
1660 noexcept
1661 {
1662 return constructStrRef("SecurityDefinition_12.InstrAttribsEntry");
1663 }
1664 };
1665
1667 typedef
1668 SbeGroup<InstrAttribsEntry, GroupSizeEncoding, MessageSize>
1669 InstrAttribs;
1670
1672 SecurityDefinition_12() = default;
1673
1675 SecurityDefinition_12(
1676 void* data,
1677 EncodedLength length,
1678 NoInit)
1679 : SbeMessage(data, length)
1680 {
1681 checkCompatibility();
1682 }
1683
1685 explicit
1686 SecurityDefinition_12(
1687 const SbeMessage& message)
1688 : SbeMessage(message)
1689 {
1690 assert(message.valid());
1691
1692 checkCompatibility();
1693 }
1694
1697 SecurityDefinition_12(
1698 void* data,
1699 EncodedLength length,
1700 NoInit,
1701 NoCheck)
1702 noexcept
1703 : SbeMessage(data, length, NoCheck())
1704 {
1705 assert(schemaId() == Schema::Id);
1706 assert(version() >= Schema::MinimalVersion);
1707 assert(TemplateId == templateId());
1708 }
1709
1711 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1712 constexpr
1718
1721 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
1722 constexpr
1723 static ApplVerID::Enum applVerId()
1724 noexcept
1725 {
1726 return ApplVerID::FIX50SP2;
1727 }
1728
1730 ONIXS_B3_UMDF_MD_NODISCARD
1731 SecurityID securityId() const
1732 noexcept
1733 {
1734 constexpr BlockLength offset = 0;
1735
1736 return ordinary<SecurityID>(offset);
1737 }
1738
1740 ONIXS_B3_UMDF_MD_NODISCARD
1741 StrRef securityExchange() const
1742 noexcept
1743 {
1744 constexpr BlockLength offset = 8;
1745 constexpr BlockLength length = 4;
1746
1747 return fixedStr<length>(offset);
1748 }
1749
1751 ONIXS_B3_UMDF_MD_NODISCARD
1752 SecurityIDSource::Enum securityIdSource() const
1753 noexcept
1754 {
1755 constexpr BlockLength offset = 12;
1756
1757 return enumeration<SecurityIDSource>(offset);
1758 }
1759
1761 ONIXS_B3_UMDF_MD_NODISCARD
1762 StrRef securityGroup() const
1763 noexcept
1764 {
1765 constexpr BlockLength offset = 13;
1766 constexpr BlockLength length = 3;
1767
1768 return fixedStr<length>(offset);
1769 }
1770
1772 ONIXS_B3_UMDF_MD_NODISCARD
1773 StrRef symbol() const
1774 noexcept
1775 {
1776 constexpr BlockLength offset = 16;
1777 constexpr BlockLength length = 20;
1778
1779 return fixedStr<length>(offset);
1780 }
1781
1783 ONIXS_B3_UMDF_MD_NODISCARD
1784 SecurityUpdateAction::Enum
1785 securityUpdateAction() const
1786 noexcept
1787 {
1788 constexpr BlockLength offset = 36;
1789
1790 return enumeration<SecurityUpdateAction>(offset);
1791 }
1792
1794 ONIXS_B3_UMDF_MD_NODISCARD
1795 SecurityType::Enum securityType() const
1796 noexcept
1797 {
1798 constexpr BlockLength offset = 37;
1799
1800 return enumeration<SecurityType>(offset);
1801 }
1802
1805 ONIXS_B3_UMDF_MD_NODISCARD
1806 UInt16 securitySubType() const
1807 noexcept
1808 {
1809 constexpr BlockLength offset = 38;
1810
1811 return ordinary<UInt16>(offset);
1812 }
1813
1816 ONIXS_B3_UMDF_MD_NODISCARD
1817 UInt32 totNoRelatedSym() const
1818 noexcept
1819 {
1820 constexpr BlockLength offset = 40;
1821
1822 return ordinary<UInt32>(offset);
1823 }
1824
1826 ONIXS_B3_UMDF_MD_NODISCARD
1827 bool minPriceIncrement(Fixed8& value) const
1828 noexcept
1829 {
1830 constexpr BlockLength offset = 44;
1831
1832 return decimal(value, offset, NullFixed8());
1833 }
1834
1836 ONIXS_B3_UMDF_MD_NODISCARD
1837 bool strikePrice(PriceOptional& value) const
1838 noexcept
1839 {
1840 constexpr BlockLength offset = 52;
1841
1842 return decimal(value, offset, NullPriceOptional());
1843 }
1844
1848 ONIXS_B3_UMDF_MD_NODISCARD
1849 bool contractMultiplier(Fixed8& value) const
1850 noexcept
1851 {
1852 constexpr BlockLength offset = 60;
1853
1854 return decimal(value, offset, NullFixed8());
1855 }
1856
1862 ONIXS_B3_UMDF_MD_NODISCARD
1863 bool priceDivisor(Fixed8& value) const
1864 noexcept
1865 {
1866 constexpr BlockLength offset = 68;
1867
1868 return decimal(value, offset, NullFixed8());
1869 }
1870
1874 ONIXS_B3_UMDF_MD_NODISCARD
1875 bool
1876 securityValidityTimestamp(
1877 UTCTimestampSeconds& value) const
1878 noexcept
1879 {
1880 constexpr BlockLength offset = 76;
1881
1882 return ordinary(value, offset, NullUTCTimestampSeconds());
1883 }
1884
1886 ONIXS_B3_UMDF_MD_NODISCARD
1887 bool sharesIssued(UInt64NULL& value) const
1888 noexcept
1889 {
1890 constexpr BlockLength offset = 84;
1891
1892 return ordinary(value, offset, NullUInt64NULL());
1893 }
1894
1896 ONIXS_B3_UMDF_MD_NODISCARD
1897 bool clearingHouseId(ClearingHouseID& value) const
1898 noexcept
1899 {
1900 constexpr BlockLength offset = 92;
1901
1902 return ordinary(value, offset, NullClearingHouseID());
1903 }
1904
1906 ONIXS_B3_UMDF_MD_NODISCARD
1907 bool minOrderQty(QuantityOptional& value) const
1908 noexcept
1909 {
1910 constexpr BlockLength offset = 100;
1911
1912 return ordinary(value, offset, NullQuantityOptional());
1913 }
1914
1916 ONIXS_B3_UMDF_MD_NODISCARD
1917 bool maxOrderQty(QuantityOptional& value) const
1918 noexcept
1919 {
1920 constexpr BlockLength offset = 108;
1921
1922 return ordinary(value, offset, NullQuantityOptional());
1923 }
1924
1927 ONIXS_B3_UMDF_MD_NODISCARD
1928 bool minLotSize(QuantityOptional& value) const
1929 noexcept
1930 {
1931 constexpr BlockLength offset = 116;
1932
1933 return ordinary(value, offset, NullQuantityOptional());
1934 }
1935
1937 ONIXS_B3_UMDF_MD_NODISCARD
1938 bool minTradeVol(QuantityOptional& value) const
1939 noexcept
1940 {
1941 constexpr BlockLength offset = 124;
1942
1943 return ordinary(value, offset, NullQuantityOptional());
1944 }
1945
1947 ONIXS_B3_UMDF_MD_NODISCARD
1948 bool corporateActionEventId(UInt32NULL& value) const
1949 noexcept
1950 {
1951 constexpr BlockLength offset = 132;
1952
1953 return ordinary(value, offset, NullUInt32NULL());
1954 }
1955
1957 ONIXS_B3_UMDF_MD_NODISCARD
1958 Timestamp issueDate() const
1959 noexcept
1960 {
1961 constexpr BlockLength offset = 136;
1962
1963 return localMktDateToTimestamp(ordinary<LocalMktDate32>(offset));
1964 }
1965
1967 ONIXS_B3_UMDF_MD_NODISCARD
1968 bool maturityDate(Timestamp& value) const
1969 noexcept
1970 {
1971 typedef LocalMktDate32Optional FieldValue;
1972
1973 constexpr BlockLength offset = 140;
1974
1975 FieldValue fieldValue;
1976
1977 if (ordinary(fieldValue, offset, NullLocalMktDate32Optional()))
1978 {
1979 value = localMktDateToTimestamp(fieldValue);
1980 return true;
1981 }
1982 return false;
1983 }
1984
1986 ONIXS_B3_UMDF_MD_NODISCARD
1987 bool countryOfIssue(StrRef& value) const
1988 noexcept
1989 {
1990 constexpr BlockLength offset = 144;
1991 constexpr BlockLength length = 2;
1992
1993 return fixedStr<length>(value, offset);
1994 }
1995
1998 ONIXS_B3_UMDF_MD_NODISCARD
1999 bool startDate(Timestamp& value) const
2000 noexcept
2001 {
2002 typedef LocalMktDate32Optional FieldValue;
2003
2004 constexpr BlockLength offset = 146;
2005
2006 FieldValue fieldValue;
2007
2008 if (ordinary(fieldValue, offset, NullLocalMktDate32Optional()))
2009 {
2010 value = localMktDateToTimestamp(fieldValue);
2011 return true;
2012 }
2013 return false;
2014 }
2015
2019 ONIXS_B3_UMDF_MD_NODISCARD
2020 bool endDate(Timestamp& value) const
2021 noexcept
2022 {
2023 typedef LocalMktDate32Optional FieldValue;
2024
2025 constexpr BlockLength offset = 150;
2026
2027 FieldValue fieldValue;
2028
2029 if (ordinary(fieldValue, offset, NullLocalMktDate32Optional()))
2030 {
2031 value = localMktDateToTimestamp(fieldValue);
2032 return true;
2033 }
2034 return false;
2035 }
2036
2038 ONIXS_B3_UMDF_MD_NODISCARD
2039 bool settlType(SettlType& value) const
2040 noexcept
2041 {
2042 constexpr BlockLength offset = 154;
2043
2044 return ordinary(value, offset, NullSettlType());
2045 }
2046
2048 ONIXS_B3_UMDF_MD_NODISCARD
2049 bool settlDate(Timestamp& value) const
2050 noexcept
2051 {
2052 typedef LocalMktDate32Optional FieldValue;
2053
2054 constexpr BlockLength offset = 156;
2055
2056 FieldValue fieldValue;
2057
2058 if (ordinary(fieldValue, offset, NullLocalMktDate32Optional()))
2059 {
2060 value = localMktDateToTimestamp(fieldValue);
2061 return true;
2062 }
2063 return false;
2064 }
2065
2068 ONIXS_B3_UMDF_MD_NODISCARD
2069 bool datedDate(Timestamp& value) const
2070 noexcept
2071 {
2072 typedef LocalMktDate32Optional FieldValue;
2073
2074 constexpr BlockLength offset = 160;
2075
2076 FieldValue fieldValue;
2077
2078 if (ordinary(fieldValue, offset, NullLocalMktDate32Optional()))
2079 {
2080 value = localMktDateToTimestamp(fieldValue);
2081 return true;
2082 }
2083 return false;
2084 }
2085
2087 ONIXS_B3_UMDF_MD_NODISCARD
2088 bool isinNumber(StrRef& value) const
2089 noexcept
2090 {
2091 constexpr BlockLength offset = 164;
2092 constexpr BlockLength length = 12;
2093
2094 return fixedStr<length>(value, offset);
2095 }
2096
2098 ONIXS_B3_UMDF_MD_NODISCARD
2099 StrRef asset() const
2100 noexcept
2101 {
2102 constexpr BlockLength offset = 176;
2103 constexpr BlockLength length = 6;
2104
2105 return fixedStr<length>(offset);
2106 }
2107
2111 ONIXS_B3_UMDF_MD_NODISCARD
2112 StrRef cfiCode() const
2113 noexcept
2114 {
2115 constexpr BlockLength offset = 182;
2116 constexpr BlockLength length = 6;
2117
2118 return fixedStr<length>(offset);
2119 }
2120
2123 ONIXS_B3_UMDF_MD_NODISCARD
2124 bool maturityMonthYear(MaturityMonthYear& value) const
2125 noexcept
2126 {
2127 constexpr BlockLength offset = 188;
2128
2129 return ordinary(value, offset, NullMaturityMonthYear());
2130 }
2131
2133 ONIXS_B3_UMDF_MD_NODISCARD
2134 bool contractSettlMonth(MaturityMonthYear& value) const
2135 noexcept
2136 {
2137 constexpr BlockLength offset = 193;
2138
2139 return ordinary(value, offset, NullMaturityMonthYear());
2140 }
2141
2143 ONIXS_B3_UMDF_MD_NODISCARD
2144 StrRef currency() const
2145 noexcept
2146 {
2147 constexpr BlockLength offset = 198;
2148 constexpr BlockLength length = 3;
2149
2150 return fixedStr<length>(offset);
2151 }
2152
2154 ONIXS_B3_UMDF_MD_NODISCARD
2155 bool strikeCurrency(StrRef& value) const
2156 noexcept
2157 {
2158 constexpr BlockLength offset = 201;
2159 constexpr BlockLength length = 3;
2160
2161 return fixedStr<length>(value, offset);
2162 }
2163
2165 ONIXS_B3_UMDF_MD_NODISCARD
2166 bool settlCurrency(StrRef& value) const
2167 noexcept
2168 {
2169 constexpr BlockLength offset = 204;
2170 constexpr BlockLength length = 3;
2171
2172 return fixedStr<length>(value, offset);
2173 }
2174
2176 ONIXS_B3_UMDF_MD_NODISCARD
2177 bool securityStrategyType(StrRef& value) const
2178 noexcept
2179 {
2180 constexpr BlockLength offset = 207;
2181 constexpr BlockLength length = 3;
2182
2183 return fixedStr<length>(value, offset);
2184 }
2185
2187 ONIXS_B3_UMDF_MD_NODISCARD
2188 bool lotType(LotType::Enum& value) const
2189 noexcept
2190 {
2191 constexpr BlockLength offset = 210;
2192
2193 return enumeration<LotType>(value, offset, NullUInt8());
2194 }
2195
2197 ONIXS_B3_UMDF_MD_NODISCARD
2198 bool tickSizeDenominator(UInt8& value) const
2199 noexcept
2200 {
2201 constexpr BlockLength offset = 211;
2202
2203 return ordinary(value, offset, NullUInt8());
2204 }
2205
2207 ONIXS_B3_UMDF_MD_NODISCARD
2208 Product::Enum product() const
2209 noexcept
2210 {
2211 constexpr BlockLength offset = 212;
2212
2213 return enumeration<Product>(offset);
2214 }
2215
2217 ONIXS_B3_UMDF_MD_NODISCARD
2218 bool
2219 exerciseStyle(
2220 ExerciseStyle::Enum& value) const
2221 noexcept
2222 {
2223 constexpr BlockLength offset = 213;
2224
2225 return enumeration<ExerciseStyle>(value, offset, NullUInt8());
2226 }
2227
2229 ONIXS_B3_UMDF_MD_NODISCARD
2230 bool putOrCall(PutOrCall::Enum& value) const
2231 noexcept
2232 {
2233 constexpr BlockLength offset = 214;
2234
2235 return enumeration<PutOrCall>(value, offset, NullUInt8());
2236 }
2237
2239 ONIXS_B3_UMDF_MD_NODISCARD
2240 bool priceType(PriceType::Enum& value) const
2241 noexcept
2242 {
2243 constexpr BlockLength offset = 215;
2244
2245 return enumeration<PriceType>(value, offset, NullUInt8NULL());
2246 }
2247
2249 ONIXS_B3_UMDF_MD_NODISCARD
2250 bool marketSegmentId(MarketSegmentID& value) const
2251 noexcept
2252 {
2253 constexpr BlockLength offset = 216;
2254
2255 return ordinary(value, offset, NullMarketSegmentID());
2256 }
2257
2259 ONIXS_B3_UMDF_MD_NODISCARD
2260 bool
2261 governanceIndicator(
2262 GovernanceIndicator::Enum& value) const
2263 noexcept
2264 {
2265 constexpr BlockLength offset = 217;
2266
2267 return enumeration<GovernanceIndicator>(value, offset, NullUInt8());
2268 }
2269
2271 ONIXS_B3_UMDF_MD_NODISCARD
2272 bool
2273 securityMatchType(
2274 SecurityMatchType::Enum& value) const
2275 noexcept
2276 {
2277 constexpr BlockLength offset = 218;
2278
2279 return enumeration<SecurityMatchType>(value, offset, NullUInt8());
2280 }
2281
2284 ONIXS_B3_UMDF_MD_NODISCARD
2285 bool lastFragment(Boolean::Enum& value) const
2286 noexcept
2287 {
2288 constexpr BlockLength offset = 219;
2289
2290 return enumeration<Boolean>(value, offset, NullUInt8());
2291 }
2292
2295 ONIXS_B3_UMDF_MD_NODISCARD
2296 bool
2297 multiLegModel(
2298 MultiLegModel::Enum& value) const
2299 noexcept
2300 {
2301 constexpr BlockLength offset = 220;
2302
2303 return enumeration<MultiLegModel>(value, offset, NullUInt8());
2304 }
2305
2309 ONIXS_B3_UMDF_MD_NODISCARD
2310 bool
2311 multiLegPriceMethod(
2312 MultiLegPriceMethod::Enum& value) const
2313 noexcept
2314 {
2315 constexpr BlockLength offset = 221;
2316
2317 return enumeration<MultiLegPriceMethod>(value, offset, NullUInt8());
2318 }
2319
2321 ONIXS_B3_UMDF_MD_NODISCARD
2322 bool minCrossQty(QuantityOptional& value) const
2323 noexcept
2324 {
2325 constexpr BlockLength offset = 222;
2326
2327 return ordinary(value, offset, NullQuantityOptional());
2328 }
2329
2332 ONIXS_B3_UMDF_MD_NODISCARD
2333 bool
2334 impliedMarketIndicator(
2335 ImpliedMarketIndicator::Enum& value) const
2336 noexcept
2337 {
2338 constexpr BlockLength offset = 230;
2339
2340 return enumeration<ImpliedMarketIndicator>(value, offset, NullUInt8());
2341 }
2342
2345 ONIXS_B3_UMDF_MD_NODISCARD
2346 bool
2347 optPayoutType(
2348 OptPayoutType::Enum& value) const
2349 noexcept
2350 {
2351 constexpr BlockLength offset = 231;
2352 constexpr SchemaVersion since = 16;
2353
2354 return enumeration<OptPayoutType>(value, offset, NullUInt8NULL(), since);
2355 }
2356
2358 ONIXS_B3_UMDF_MD_NODISCARD
2359 Underlyings underlyings() const
2360 noexcept
2361 {
2362 return getGroup<Underlyings>(
2363 UnderlyingsAccess(),
2364 *this);
2365 }
2366
2368 ONIXS_B3_UMDF_MD_NODISCARD
2369 Legs legs() const
2370 noexcept
2371 {
2372 return getGroup<Legs>(LegsAccess(), *this);
2373 }
2374
2376 ONIXS_B3_UMDF_MD_NODISCARD
2377 InstrAttribs instrAttribs() const
2378 noexcept
2379 {
2380 return getGroup<InstrAttribs>(
2381 InstrAttribsAccess(),
2382 *this);
2383 }
2384
2386 ONIXS_B3_UMDF_MD_NODISCARD
2387 StrRef securityDesc() const
2388 noexcept
2389 {
2390 return getVariableLengthField(
2391 securityDescAccess(),
2392 *this);
2393 }
2394
2396 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2397 constexpr
2398 static BlockLength minimalBlockLength(SchemaVersion version)
2399 noexcept
2400 {
2401 return
2402 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
2403 (version >= 16)
2404 ? 232
2405 : 231;
2406 }
2407
2409 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2410 constexpr
2411 static BlockLength blockLength(SchemaVersion version)
2412 noexcept
2413 {
2414 return
2415 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
2416 minimalBlockLength(version);
2417 }
2418
2420 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2421 ONIXS_B3_UMDF_MD_NODISCARD
2422 constexpr
2423 static
2424 MessageSize
2425 getMinimalVariableFieldsSize(
2426 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
2427 {
2428 return
2429 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
2430 static_cast<MessageSize>(TextEncoding::Size) + static_cast<MessageSize>(Underlyings::EmptySize) + static_cast<MessageSize>(Legs::EmptySize) + static_cast<MessageSize>(InstrAttribs::EmptySize);
2431 }
2432
2434 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2435 ONIXS_B3_UMDF_MD_NODISCARD
2436 constexpr
2437 static StrRef className()
2438 noexcept
2439 {
2440 return constructStrRef("SecurityDefinition_12");
2441 }
2442
2444 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2445 ONIXS_B3_UMDF_MD_NODISCARD
2446 constexpr
2447 static StrRef fixType()
2448 noexcept
2449 {
2450 return constructStrRef("SecurityDefinition_12");
2451 }
2452
2454 ONIXS_B3_UMDF_MD_NODISCARD
2455 std::string toString() const;
2456
2457private:
2458 void checkLength(
2459 EncodedLength length, SchemaVersion version) const
2460 {
2461 const EncodedLength minimalRequiredLength =
2462 minimalBlockLength(version) +
2463 MessageHeader::Size +
2464 getMinimalVariableFieldsSize(version);
2465
2466 checkBinaryLength(
2467 *this, length, minimalRequiredLength);
2468 }
2469
2471 void checkVarLenFields() const
2472 {
2473 groups().
2474 tail<Underlyings>().
2475 tail<Legs>().
2476 checkVariableLengthFields<InstrAttribs>().
2477 checkTail<TextEncoding>();
2478 }
2479
2480 void checkCompatibility() const
2481 {
2482 assert(TemplateId == templateId());
2483
2484 checkSchema<Schema>(schemaId(), version());
2485 checkLength(bufferSize(), version());
2486 checkVarLenFields();
2487 }
2488
2490 struct UnderlyingsAccess
2491 {
2492 Underlyings
2493 operator()(
2494 const SecurityDefinition_12& obj) const
2495 noexcept
2496 {
2497 return obj.
2498 groups().
2499 head<Underlyings>();
2500 }
2501 };
2502
2504 struct LegsAccess
2505 {
2506 Legs
2507 operator()(
2508 const SecurityDefinition_12& obj) const
2509 noexcept
2510 {
2511 return obj.
2512 groups().
2513 tail<Underlyings>().
2514 head<Legs>();
2515 }
2516 };
2517
2519 struct InstrAttribsAccess
2520 {
2521 InstrAttribs
2522 operator()(
2523 const SecurityDefinition_12& obj) const
2524 noexcept
2525 {
2526 return obj.
2527 groups().
2528 tail<Underlyings>().
2529 tail<Legs>().
2530 head<InstrAttribs>();
2531 }
2532 };
2533
2535 struct securityDescAccess
2536 {
2537 TextEncoding&
2538 operator()(
2539 const SecurityDefinition_12& obj) const
2540 noexcept
2541 {
2542 return obj.
2543 groups().
2544 tail<Underlyings>().
2545 tail<Legs>().
2546 variableLengthFields<InstrAttribs>().
2547 head<TextEncoding>();
2548 }
2549 };
2550};
2551
2553ONIXS_B3_UMDF_MD_LTWT_STRUCT
2554News_5
2555: SbeMessage
2556{
2558 typedef SchemaTraits Schema;
2559
2561 enum { TemplateId = 5 };
2562
2564 News_5() = default;
2565
2567 News_5(
2568 void* data,
2569 EncodedLength length,
2570 NoInit)
2571 : SbeMessage(data, length)
2572 {
2573 checkCompatibility();
2574 }
2575
2577 explicit
2578 News_5(
2579 const SbeMessage& message)
2580 : SbeMessage(message)
2581 {
2582 assert(message.valid());
2583
2584 checkCompatibility();
2585 }
2586
2589 News_5(
2590 void* data,
2591 EncodedLength length,
2592 NoInit,
2593 NoCheck)
2594 noexcept
2595 : SbeMessage(data, length, NoCheck())
2596 {
2597 assert(schemaId() == Schema::Id);
2598 assert(version() >= Schema::MinimalVersion);
2599 assert(TemplateId == templateId());
2600 }
2601
2603 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2604 constexpr
2605 static MessageType::Enum messageType()
2606 noexcept
2607 {
2608 return MessageType::News;
2609 }
2610
2613 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2614 constexpr
2615 static ApplVerID::Enum applVerId()
2616 noexcept
2617 {
2618 return ApplVerID::FIX50SP2;
2619 }
2620
2623 ONIXS_B3_UMDF_MD_NODISCARD
2624 bool
2625 securityId(
2626 SecurityIDOptional& value) const
2627 noexcept
2628 {
2629 constexpr BlockLength offset = 0;
2630
2631 return ordinary(value, offset, NullSecurityIDOptional());
2632 }
2633
2635 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2636 constexpr
2642
2644 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2645 ONIXS_B3_UMDF_MD_NODISCARD
2646 constexpr
2647 static StrRef securityExchange()
2648 noexcept
2649 {
2650 return constructStrRef("BVMF");
2651 }
2652
2655 ONIXS_B3_UMDF_MD_NODISCARD
2656 MatchEventIndicator matchEventIndicator() const
2657 noexcept
2658 {
2659 constexpr BlockLength offset = 8;
2660
2661 return ordinary<MatchEventIndicator>(offset);
2662 }
2663
2665 ONIXS_B3_UMDF_MD_NODISCARD
2666 NewsSource::Enum newsSource() const
2667 noexcept
2668 {
2669 constexpr BlockLength offset = 9;
2670
2671 return enumeration<NewsSource>(offset);
2672 }
2673
2676 ONIXS_B3_UMDF_MD_NODISCARD
2677 bool languageCode(StrRef& value) const
2678 noexcept
2679 {
2680 constexpr BlockLength offset = 10;
2681 constexpr BlockLength length = 2;
2682
2683 return fixedStr<length>(value, offset);
2684 }
2685
2688 ONIXS_B3_UMDF_MD_NODISCARD
2689 UInt16 partCount() const
2690 noexcept
2691 {
2692 constexpr BlockLength offset = 12;
2693
2694 return ordinary<UInt16>(offset);
2695 }
2696
2698 ONIXS_B3_UMDF_MD_NODISCARD
2699 UInt16 partNumber() const
2700 noexcept
2701 {
2702 constexpr BlockLength offset = 14;
2703
2704 return ordinary<UInt16>(offset);
2705 }
2706
2710 ONIXS_B3_UMDF_MD_NODISCARD
2711 bool newsId(NewsID& value) const
2712 noexcept
2713 {
2714 constexpr BlockLength offset = 16;
2715
2716 return ordinary(value, offset, NullNewsID());
2717 }
2718
2720 ONIXS_B3_UMDF_MD_NODISCARD
2721 bool origTime(UTCTimestampNanos& value) const
2722 noexcept
2723 {
2724 constexpr BlockLength offset = 24;
2725
2726 return ordinary(value, offset, NullUTCTimestampNanos());
2727 }
2728
2730 ONIXS_B3_UMDF_MD_NODISCARD
2731 UInt32 totalTextLength() const
2732 noexcept
2733 {
2734 constexpr BlockLength offset = 32;
2735
2736 return ordinary<UInt32>(offset);
2737 }
2738
2740 ONIXS_B3_UMDF_MD_NODISCARD
2741 StrRef headline() const
2742 noexcept
2743 {
2744 return getVariableLengthField(headlineAccess(), *this);
2745 }
2746
2748 ONIXS_B3_UMDF_MD_NODISCARD
2749 StrRef text() const
2750 noexcept
2751 {
2752 return getVariableLengthField(textAccess(), *this);
2753 }
2754
2756 ONIXS_B3_UMDF_MD_NODISCARD
2757 StrRef uRLLink() const
2758 noexcept
2759 {
2760 return getVariableLengthField(uRLLinkAccess(), *this);
2761 }
2762
2764 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2765 constexpr
2766 static
2767 BlockLength
2768 minimalBlockLength(
2769 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
2770 noexcept
2771 {
2772 return
2773 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
2774 36;
2775 }
2776
2778 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2779 constexpr
2780 static BlockLength blockLength(SchemaVersion version)
2781 noexcept
2782 {
2783 return
2784 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
2785 minimalBlockLength(version);
2786 }
2787
2789 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2790 ONIXS_B3_UMDF_MD_NODISCARD
2791 constexpr
2792 static
2793 MessageSize
2794 getMinimalVariableFieldsSize(
2795 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
2796 {
2797 return
2798 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
2799 static_cast<MessageSize>(VarString::Size) + static_cast<MessageSize>(VarString::Size) + static_cast<MessageSize>(VarString::Size);
2800 }
2801
2803 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2804 ONIXS_B3_UMDF_MD_NODISCARD
2805 constexpr
2806 static StrRef className()
2807 noexcept
2808 {
2809 return constructStrRef("News_5");
2810 }
2811
2813 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2814 ONIXS_B3_UMDF_MD_NODISCARD
2815 constexpr
2816 static StrRef fixType()
2817 noexcept
2818 {
2819 return constructStrRef("B");
2820 }
2821
2823 ONIXS_B3_UMDF_MD_NODISCARD
2824 std::string toString() const;
2825
2826private:
2827 void checkLength(
2828 EncodedLength length, SchemaVersion version) const
2829 {
2830 const EncodedLength minimalRequiredLength =
2831 minimalBlockLength(version) +
2832 MessageHeader::Size +
2833 getMinimalVariableFieldsSize(version);
2834
2835 checkBinaryLength(
2836 *this, length, minimalRequiredLength);
2837 }
2838
2840 void checkVarLenFields() const
2841 {
2842 variableLengthFields().
2843 checkTail<VarString>().
2844 checkTail<VarString>().
2845 checkTail<VarString>();
2846 }
2847
2848 void checkCompatibility() const
2849 {
2850 assert(TemplateId == templateId());
2851
2852 checkSchema<Schema>(schemaId(), version());
2853 checkLength(bufferSize(), version());
2854 checkVarLenFields();
2855 }
2856
2858 struct headlineAccess
2859 {
2860 VarString& operator()(const News_5& obj) const
2861 noexcept
2862 {
2863 return obj.
2864 variableLengthFields().
2865 head<VarString>();
2866 }
2867 };
2868
2870 struct textAccess
2871 {
2872 VarString& operator()(const News_5& obj) const
2873 noexcept
2874 {
2875 return obj.
2876 variableLengthFields().
2877 tail<VarString>().
2878 head<VarString>();
2879 }
2880 };
2881
2883 struct uRLLinkAccess
2884 {
2885 VarString& operator()(const News_5& obj) const
2886 noexcept
2887 {
2888 return obj.
2889 variableLengthFields().
2890 tail<VarString>().
2891 tail<VarString>().
2892 head<VarString>();
2893 }
2894 };
2895};
2896
2898ONIXS_B3_UMDF_MD_LTWT_STRUCT
2899OpeningPrice_15
2900: SbeMessage
2901{
2903 typedef SchemaTraits Schema;
2904
2906 enum { TemplateId = 15 };
2907
2909 OpeningPrice_15() = default;
2910
2912 OpeningPrice_15(
2913 void* data,
2914 EncodedLength length,
2915 NoInit)
2916 : SbeMessage(data, length)
2917 {
2918 checkCompatibility();
2919 }
2920
2922 explicit
2923 OpeningPrice_15(
2924 const SbeMessage& message)
2925 : SbeMessage(message)
2926 {
2927 assert(message.valid());
2928
2929 checkCompatibility();
2930 }
2931
2934 OpeningPrice_15(
2935 void* data,
2936 EncodedLength length,
2937 NoInit,
2938 NoCheck)
2939 noexcept
2940 : SbeMessage(data, length, NoCheck())
2941 {
2942 assert(schemaId() == Schema::Id);
2943 assert(version() >= Schema::MinimalVersion);
2944 assert(TemplateId == templateId());
2945 }
2946
2948 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2949 constexpr
2955
2958 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2959 constexpr
2960 static ApplVerID::Enum applVerId()
2961 noexcept
2962 {
2963 return ApplVerID::FIX50SP2;
2964 }
2965
2968 ONIXS_B3_UMDF_MD_NODISCARD
2969 SecurityID securityId() const
2970 noexcept
2971 {
2972 constexpr BlockLength offset = 0;
2973
2974 return ordinary<SecurityID>(offset);
2975 }
2976
2978 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2979 constexpr
2985
2987 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
2988 ONIXS_B3_UMDF_MD_NODISCARD
2989 constexpr
2990 static StrRef securityExchange()
2991 noexcept
2992 {
2993 return constructStrRef("BVMF");
2994 }
2995
2998 ONIXS_B3_UMDF_MD_NODISCARD
2999 MatchEventIndicator matchEventIndicator() const
3000 noexcept
3001 {
3002 constexpr BlockLength offset = 8;
3003
3004 return ordinary<MatchEventIndicator>(offset);
3005 }
3006
3008 ONIXS_B3_UMDF_MD_NODISCARD
3009 UpdateAction::Enum mDUpdateAction() const
3010 noexcept
3011 {
3012 constexpr BlockLength offset = 9;
3013
3014 return enumeration<UpdateAction>(offset);
3015 }
3016
3018 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3019 constexpr
3020 static EntryType::Enum mDEntryType()
3021 noexcept
3022 {
3023 return EntryType::OPENING_PRICE;
3024 }
3025
3028 ONIXS_B3_UMDF_MD_NODISCARD
3029 OpenCloseSettlFlag::Enum openCloseSettlFlag() const
3030 noexcept
3031 {
3032 constexpr BlockLength offset = 10;
3033
3034 return enumeration<OpenCloseSettlFlag>(offset);
3035 }
3036
3038 ONIXS_B3_UMDF_MD_NODISCARD
3039 Price mDEntryPx() const
3040 noexcept
3041 {
3042 constexpr BlockLength offset = 12;
3043
3044 return decimal<Price>(offset);
3045 }
3046
3049 ONIXS_B3_UMDF_MD_NODISCARD
3050 bool
3051 netChgPrevDay(
3052 PriceOffset8Optional& value) const
3053 noexcept
3054 {
3055 constexpr BlockLength offset = 20;
3056
3057 return decimal(value, offset, NullPriceOffset8Optional());
3058 }
3059
3062 ONIXS_B3_UMDF_MD_NODISCARD
3063 Timestamp tradeDate() const
3064 noexcept
3065 {
3066 constexpr BlockLength offset = 28;
3067
3068 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
3069 }
3070
3072 ONIXS_B3_UMDF_MD_NODISCARD
3073 bool mDEntryTimestamp(UTCTimestampNanos& value) const
3074 noexcept
3075 {
3076 constexpr BlockLength offset = 30;
3077
3078 return ordinary(value, offset, NullUTCTimestampNanos());
3079 }
3080
3083 ONIXS_B3_UMDF_MD_NODISCARD
3084 bool rptSeq(RptSeq& value) const
3085 noexcept
3086 {
3087 constexpr BlockLength offset = 38;
3088
3089 return ordinary(value, offset, NullRptSeq());
3090 }
3091
3093 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3094 constexpr
3095 static
3096 BlockLength
3097 minimalBlockLength(
3098 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3099 noexcept
3100 {
3101 return
3102 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3103 44;
3104 }
3105
3107 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3108 constexpr
3109 static
3110 BlockLength
3111 blockLength(
3112 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3113 noexcept
3114 {
3115 return
3116 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3117 44;
3118 }
3119
3121 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3122 ONIXS_B3_UMDF_MD_NODISCARD
3123 constexpr
3124 static
3125 MessageSize
3126 getMinimalVariableFieldsSize(
3127 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3128 {
3129 return
3130 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3131 0;
3132 }
3133
3135 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3136 ONIXS_B3_UMDF_MD_NODISCARD
3137 constexpr
3138 static StrRef className()
3139 noexcept
3140 {
3141 return constructStrRef("OpeningPrice_15");
3142 }
3143
3145 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3146 ONIXS_B3_UMDF_MD_NODISCARD
3147 constexpr
3148 static StrRef fixType()
3149 noexcept
3150 {
3151 return constructStrRef("OpeningPrice_15");
3152 }
3153
3155 ONIXS_B3_UMDF_MD_NODISCARD
3156 std::string toString() const;
3157
3158private:
3159 void checkLength(
3160 EncodedLength length, SchemaVersion version) const
3161 {
3162 const EncodedLength minimalRequiredLength =
3163 minimalBlockLength(version) +
3164 MessageHeader::Size +
3165 getMinimalVariableFieldsSize(version);
3166
3167 checkBinaryLength(
3168 *this, length, minimalRequiredLength);
3169 }
3170
3171 void checkCompatibility() const
3172 {
3173 assert(TemplateId == templateId());
3174
3175 checkSchema<Schema>(schemaId(), version());
3176 checkLength(bufferSize(), version());
3177 }
3178};
3179
3181ONIXS_B3_UMDF_MD_LTWT_STRUCT
3182TheoreticalOpeningPrice_16
3183: SbeMessage
3184{
3186 typedef SchemaTraits Schema;
3187
3189 enum { TemplateId = 16 };
3190
3192 TheoreticalOpeningPrice_16() = default;
3193
3195 TheoreticalOpeningPrice_16(
3196 void* data,
3197 EncodedLength length,
3198 NoInit)
3199 : SbeMessage(data, length)
3200 {
3201 checkCompatibility();
3202 }
3203
3205 explicit
3206 TheoreticalOpeningPrice_16(
3207 const SbeMessage& message)
3208 : SbeMessage(message)
3209 {
3210 assert(message.valid());
3211
3212 checkCompatibility();
3213 }
3214
3217 TheoreticalOpeningPrice_16(
3218 void* data,
3219 EncodedLength length,
3220 NoInit,
3221 NoCheck)
3222 noexcept
3223 : SbeMessage(data, length, NoCheck())
3224 {
3225 assert(schemaId() == Schema::Id);
3226 assert(version() >= Schema::MinimalVersion);
3227 assert(TemplateId == templateId());
3228 }
3229
3231 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3232 constexpr
3238
3241 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3242 constexpr
3243 static ApplVerID::Enum applVerId()
3244 noexcept
3245 {
3246 return ApplVerID::FIX50SP2;
3247 }
3248
3251 ONIXS_B3_UMDF_MD_NODISCARD
3252 SecurityID securityId() const
3253 noexcept
3254 {
3255 constexpr BlockLength offset = 0;
3256
3257 return ordinary<SecurityID>(offset);
3258 }
3259
3261 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3262 constexpr
3268
3270 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3271 ONIXS_B3_UMDF_MD_NODISCARD
3272 constexpr
3273 static StrRef securityExchange()
3274 noexcept
3275 {
3276 return constructStrRef("BVMF");
3277 }
3278
3281 ONIXS_B3_UMDF_MD_NODISCARD
3282 MatchEventIndicator matchEventIndicator() const
3283 noexcept
3284 {
3285 constexpr BlockLength offset = 8;
3286
3287 return ordinary<MatchEventIndicator>(offset);
3288 }
3289
3291 ONIXS_B3_UMDF_MD_NODISCARD
3292 UpdateAction::Enum mDUpdateAction() const
3293 noexcept
3294 {
3295 constexpr BlockLength offset = 9;
3296
3297 return enumeration<UpdateAction>(offset);
3298 }
3299
3301 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3302 constexpr
3303 static EntryType::Enum mDEntryType()
3304 noexcept
3305 {
3306 return EntryType::OPENING_PRICE;
3307 }
3308
3310 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3311 constexpr
3312 static OpenCloseSettlFlag::Enum openCloseSettlFlag()
3313 noexcept
3314 {
3315 return OpenCloseSettlFlag::THEORETICAL_PRICE;
3316 }
3317
3320 ONIXS_B3_UMDF_MD_NODISCARD
3321 Timestamp tradeDate() const
3322 noexcept
3323 {
3324 constexpr BlockLength offset = 10;
3325
3326 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
3327 }
3328
3330 ONIXS_B3_UMDF_MD_NODISCARD
3331 bool mDEntryPx(PriceOptional& value) const
3332 noexcept
3333 {
3334 constexpr BlockLength offset = 12;
3335
3336 return decimal(value, offset, NullPriceOptional());
3337 }
3338
3340 ONIXS_B3_UMDF_MD_NODISCARD
3341 bool mDEntrySize(QuantityOptional& value) const
3342 noexcept
3343 {
3344 constexpr BlockLength offset = 20;
3345
3346 return ordinary(value, offset, NullQuantityOptional());
3347 }
3348
3350 ONIXS_B3_UMDF_MD_NODISCARD
3351 bool mDEntryTimestamp(UTCTimestampNanos& value) const
3352 noexcept
3353 {
3354 constexpr BlockLength offset = 28;
3355
3356 return ordinary(value, offset, NullUTCTimestampNanos());
3357 }
3358
3361 ONIXS_B3_UMDF_MD_NODISCARD
3362 bool rptSeq(RptSeq& value) const
3363 noexcept
3364 {
3365 constexpr BlockLength offset = 36;
3366
3367 return ordinary(value, offset, NullRptSeq());
3368 }
3369
3371 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3372 constexpr
3373 static
3374 BlockLength
3375 minimalBlockLength(
3376 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3377 noexcept
3378 {
3379 return
3380 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3381 40;
3382 }
3383
3385 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3386 constexpr
3387 static BlockLength blockLength(SchemaVersion version)
3388 noexcept
3389 {
3390 return
3391 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3392 minimalBlockLength(version);
3393 }
3394
3396 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3397 ONIXS_B3_UMDF_MD_NODISCARD
3398 constexpr
3399 static
3400 MessageSize
3401 getMinimalVariableFieldsSize(
3402 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3403 {
3404 return
3405 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3406 0;
3407 }
3408
3410 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3411 ONIXS_B3_UMDF_MD_NODISCARD
3412 constexpr
3413 static StrRef className()
3414 noexcept
3415 {
3416 return constructStrRef("TheoreticalOpeningPrice_16");
3417 }
3418
3420 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3421 ONIXS_B3_UMDF_MD_NODISCARD
3422 constexpr
3423 static StrRef fixType()
3424 noexcept
3425 {
3426 return constructStrRef(
3427 "TheoreticalOpeningPrice_16");
3428 }
3429
3431 ONIXS_B3_UMDF_MD_NODISCARD
3432 std::string toString() const;
3433
3434private:
3435 void checkLength(
3436 EncodedLength length, SchemaVersion version) const
3437 {
3438 const EncodedLength minimalRequiredLength =
3439 minimalBlockLength(version) +
3440 MessageHeader::Size +
3441 getMinimalVariableFieldsSize(version);
3442
3443 checkBinaryLength(
3444 *this, length, minimalRequiredLength);
3445 }
3446
3447 void checkCompatibility() const
3448 {
3449 assert(TemplateId == templateId());
3450
3451 checkSchema<Schema>(schemaId(), version());
3452 checkLength(bufferSize(), version());
3453 }
3454};
3455
3457ONIXS_B3_UMDF_MD_LTWT_STRUCT
3458ClosingPrice_17
3459: SbeMessage
3460{
3462 typedef SchemaTraits Schema;
3463
3465 enum { TemplateId = 17 };
3466
3468 ClosingPrice_17() = default;
3469
3471 ClosingPrice_17(
3472 void* data,
3473 EncodedLength length,
3474 NoInit)
3475 : SbeMessage(data, length)
3476 {
3477 checkCompatibility();
3478 }
3479
3481 explicit
3482 ClosingPrice_17(
3483 const SbeMessage& message)
3484 : SbeMessage(message)
3485 {
3486 assert(message.valid());
3487
3488 checkCompatibility();
3489 }
3490
3493 ClosingPrice_17(
3494 void* data,
3495 EncodedLength length,
3496 NoInit,
3497 NoCheck)
3498 noexcept
3499 : SbeMessage(data, length, NoCheck())
3500 {
3501 assert(schemaId() == Schema::Id);
3502 assert(version() >= Schema::MinimalVersion);
3503 assert(TemplateId == templateId());
3504 }
3505
3507 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3508 constexpr
3514
3517 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3518 constexpr
3519 static ApplVerID::Enum applVerId()
3520 noexcept
3521 {
3522 return ApplVerID::FIX50SP2;
3523 }
3524
3527 ONIXS_B3_UMDF_MD_NODISCARD
3528 SecurityID securityId() const
3529 noexcept
3530 {
3531 constexpr BlockLength offset = 0;
3532
3533 return ordinary<SecurityID>(offset);
3534 }
3535
3537 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3538 constexpr
3544
3546 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3547 ONIXS_B3_UMDF_MD_NODISCARD
3548 constexpr
3549 static StrRef securityExchange()
3550 noexcept
3551 {
3552 return constructStrRef("BVMF");
3553 }
3554
3557 ONIXS_B3_UMDF_MD_NODISCARD
3558 MatchEventIndicator matchEventIndicator() const
3559 noexcept
3560 {
3561 constexpr BlockLength offset = 8;
3562
3563 return ordinary<MatchEventIndicator>(offset);
3564 }
3565
3567 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3568 constexpr
3569 static UpdateAction::Enum mDUpdateAction()
3570 noexcept
3571 {
3572 return UpdateAction::NEW;
3573 }
3574
3576 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3577 constexpr
3578 static EntryType::Enum mDEntryType()
3579 noexcept
3580 {
3581 return EntryType::CLOSING_PRICE;
3582 }
3583
3586 ONIXS_B3_UMDF_MD_NODISCARD
3587 OpenCloseSettlFlag::Enum openCloseSettlFlag() const
3588 noexcept
3589 {
3590 constexpr BlockLength offset = 9;
3591
3592 return enumeration<OpenCloseSettlFlag>(offset);
3593 }
3594
3596 ONIXS_B3_UMDF_MD_NODISCARD
3597 Price8 mDEntryPx() const
3598 noexcept
3599 {
3600 constexpr BlockLength offset = 12;
3601
3602 return decimal<Price8>(offset);
3603 }
3604
3606 ONIXS_B3_UMDF_MD_NODISCARD
3607 bool lastTradeDate(Timestamp& value) const
3608 noexcept
3609 {
3610 typedef LocalMktDateOptional FieldValue;
3611
3612 constexpr BlockLength offset = 20;
3613
3614 FieldValue fieldValue;
3615
3616 if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
3617 {
3618 value = localMktDateToTimestamp(fieldValue);
3619 return true;
3620 }
3621 return false;
3622 }
3623
3626 ONIXS_B3_UMDF_MD_NODISCARD
3627 Timestamp tradeDate() const
3628 noexcept
3629 {
3630 constexpr BlockLength offset = 22;
3631
3632 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
3633 }
3634
3636 ONIXS_B3_UMDF_MD_NODISCARD
3637 bool mDEntryTimestamp(UTCTimestampNanos& value) const
3638 noexcept
3639 {
3640 constexpr BlockLength offset = 24;
3641
3642 return ordinary(value, offset, NullUTCTimestampNanos());
3643 }
3644
3647 ONIXS_B3_UMDF_MD_NODISCARD
3648 bool rptSeq(RptSeq& value) const
3649 noexcept
3650 {
3651 constexpr BlockLength offset = 32;
3652
3653 return ordinary(value, offset, NullRptSeq());
3654 }
3655
3657 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3658 constexpr
3659 static
3660 BlockLength
3661 minimalBlockLength(
3662 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3663 noexcept
3664 {
3665 return
3666 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3667 36;
3668 }
3669
3671 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3672 constexpr
3673 static
3674 BlockLength
3675 blockLength(
3676 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3677 noexcept
3678 {
3679 return
3680 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3681 minimalBlockLength(version);
3682 }
3683
3685 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3686 ONIXS_B3_UMDF_MD_NODISCARD
3687 constexpr
3688 static
3689 MessageSize
3690 getMinimalVariableFieldsSize(
3691 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3692 {
3693 return
3694 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3695 0;
3696 }
3697
3699 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3700 ONIXS_B3_UMDF_MD_NODISCARD
3701 constexpr
3702 static StrRef className()
3703 noexcept
3704 {
3705 return constructStrRef("ClosingPrice_17");
3706 }
3707
3709 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3710 ONIXS_B3_UMDF_MD_NODISCARD
3711 constexpr
3712 static StrRef fixType()
3713 noexcept
3714 {
3715 return constructStrRef("ClosingPrice_17");
3716 }
3717
3719 ONIXS_B3_UMDF_MD_NODISCARD
3720 std::string toString() const;
3721
3722private:
3723 void checkLength(
3724 EncodedLength length, SchemaVersion version) const
3725 {
3726 const EncodedLength minimalRequiredLength =
3727 minimalBlockLength(version) +
3728 MessageHeader::Size +
3729 getMinimalVariableFieldsSize(version);
3730
3731 checkBinaryLength(
3732 *this, length, minimalRequiredLength);
3733 }
3734
3735 void checkCompatibility() const
3736 {
3737 assert(TemplateId == templateId());
3738
3739 checkSchema<Schema>(schemaId(), version());
3740 checkLength(bufferSize(), version());
3741 }
3742};
3743
3745ONIXS_B3_UMDF_MD_LTWT_STRUCT
3746AuctionImbalance_19
3747: SbeMessage
3748{
3750 typedef SchemaTraits Schema;
3751
3753 enum { TemplateId = 19 };
3754
3756 AuctionImbalance_19() = default;
3757
3759 AuctionImbalance_19(
3760 void* data,
3761 EncodedLength length,
3762 NoInit)
3763 : SbeMessage(data, length)
3764 {
3765 checkCompatibility();
3766 }
3767
3769 explicit
3770 AuctionImbalance_19(
3771 const SbeMessage& message)
3772 : SbeMessage(message)
3773 {
3774 assert(message.valid());
3775
3776 checkCompatibility();
3777 }
3778
3781 AuctionImbalance_19(
3782 void* data,
3783 EncodedLength length,
3784 NoInit,
3785 NoCheck)
3786 noexcept
3787 : SbeMessage(data, length, NoCheck())
3788 {
3789 assert(schemaId() == Schema::Id);
3790 assert(version() >= Schema::MinimalVersion);
3791 assert(TemplateId == templateId());
3792 }
3793
3795 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3796 constexpr
3802
3805 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3806 constexpr
3807 static ApplVerID::Enum applVerId()
3808 noexcept
3809 {
3810 return ApplVerID::FIX50SP2;
3811 }
3812
3815 ONIXS_B3_UMDF_MD_NODISCARD
3816 SecurityID securityId() const
3817 noexcept
3818 {
3819 constexpr BlockLength offset = 0;
3820
3821 return ordinary<SecurityID>(offset);
3822 }
3823
3825 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3826 constexpr
3832
3834 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3835 ONIXS_B3_UMDF_MD_NODISCARD
3836 constexpr
3837 static StrRef securityExchange()
3838 noexcept
3839 {
3840 return constructStrRef("BVMF");
3841 }
3842
3845 ONIXS_B3_UMDF_MD_NODISCARD
3846 MatchEventIndicator matchEventIndicator() const
3847 noexcept
3848 {
3849 constexpr BlockLength offset = 8;
3850
3851 return ordinary<MatchEventIndicator>(offset);
3852 }
3853
3855 ONIXS_B3_UMDF_MD_NODISCARD
3856 UpdateAction::Enum mDUpdateAction() const
3857 noexcept
3858 {
3859 constexpr BlockLength offset = 9;
3860
3861 return enumeration<UpdateAction>(offset);
3862 }
3863
3865 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3866 constexpr
3867 static EntryType::Enum mDEntryType()
3868 noexcept
3869 {
3870 return EntryType::IMBALANCE;
3871 }
3872
3875 ONIXS_B3_UMDF_MD_NODISCARD
3876 ImbalanceCondition imbalanceCondition() const
3877 noexcept
3878 {
3879 constexpr BlockLength offset = 10;
3880
3881 return ordinary<ImbalanceCondition>(offset);
3882 }
3883
3885 ONIXS_B3_UMDF_MD_NODISCARD
3886 bool mDEntrySize(QuantityOptional& value) const
3887 noexcept
3888 {
3889 constexpr BlockLength offset = 12;
3890
3891 return ordinary(value, offset, NullQuantityOptional());
3892 }
3893
3895 ONIXS_B3_UMDF_MD_NODISCARD
3896 bool mDEntryTimestamp(UTCTimestampNanos& value) const
3897 noexcept
3898 {
3899 constexpr BlockLength offset = 20;
3900
3901 return ordinary(value, offset, NullUTCTimestampNanos());
3902 }
3903
3906 ONIXS_B3_UMDF_MD_NODISCARD
3907 bool rptSeq(RptSeq& value) const
3908 noexcept
3909 {
3910 constexpr BlockLength offset = 28;
3911
3912 return ordinary(value, offset, NullRptSeq());
3913 }
3914
3916 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3917 constexpr
3918 static
3919 BlockLength
3920 minimalBlockLength(
3921 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3922 noexcept
3923 {
3924 return
3925 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3926 32;
3927 }
3928
3930 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3931 constexpr
3932 static BlockLength blockLength(SchemaVersion version)
3933 noexcept
3934 {
3935 return
3936 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3937 minimalBlockLength(version);
3938 }
3939
3941 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3942 ONIXS_B3_UMDF_MD_NODISCARD
3943 constexpr
3944 static
3945 MessageSize
3946 getMinimalVariableFieldsSize(
3947 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
3948 {
3949 return
3950 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
3951 0;
3952 }
3953
3955 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3956 ONIXS_B3_UMDF_MD_NODISCARD
3957 constexpr
3958 static StrRef className()
3959 noexcept
3960 {
3961 return constructStrRef("AuctionImbalance_19");
3962 }
3963
3965 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
3966 ONIXS_B3_UMDF_MD_NODISCARD
3967 constexpr
3968 static StrRef fixType()
3969 noexcept
3970 {
3971 return constructStrRef("AuctionImbalance_19");
3972 }
3973
3975 ONIXS_B3_UMDF_MD_NODISCARD
3976 std::string toString() const;
3977
3978private:
3979 void checkLength(
3980 EncodedLength length, SchemaVersion version) const
3981 {
3982 const EncodedLength minimalRequiredLength =
3983 minimalBlockLength(version) +
3984 MessageHeader::Size +
3985 getMinimalVariableFieldsSize(version);
3986
3987 checkBinaryLength(
3988 *this, length, minimalRequiredLength);
3989 }
3990
3991 void checkCompatibility() const
3992 {
3993 assert(TemplateId == templateId());
3994
3995 checkSchema<Schema>(schemaId(), version());
3996 checkLength(bufferSize(), version());
3997 }
3998};
3999
4001ONIXS_B3_UMDF_MD_LTWT_STRUCT
4002QuantityBand_21
4003: SbeMessage
4004{
4006 typedef SchemaTraits Schema;
4007
4009 enum { TemplateId = 21 };
4010
4012 QuantityBand_21() = default;
4013
4015 QuantityBand_21(
4016 void* data,
4017 EncodedLength length,
4018 NoInit)
4019 : SbeMessage(data, length)
4020 {
4021 checkCompatibility();
4022 }
4023
4025 explicit
4026 QuantityBand_21(
4027 const SbeMessage& message)
4028 : SbeMessage(message)
4029 {
4030 assert(message.valid());
4031
4032 checkCompatibility();
4033 }
4034
4037 QuantityBand_21(
4038 void* data,
4039 EncodedLength length,
4040 NoInit,
4041 NoCheck)
4042 noexcept
4043 : SbeMessage(data, length, NoCheck())
4044 {
4045 assert(schemaId() == Schema::Id);
4046 assert(version() >= Schema::MinimalVersion);
4047 assert(TemplateId == templateId());
4048 }
4049
4051 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4052 constexpr
4058
4061 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4062 constexpr
4063 static ApplVerID::Enum applVerId()
4064 noexcept
4065 {
4066 return ApplVerID::FIX50SP2;
4067 }
4068
4071 ONIXS_B3_UMDF_MD_NODISCARD
4072 SecurityID securityId() const
4073 noexcept
4074 {
4075 constexpr BlockLength offset = 0;
4076
4077 return ordinary<SecurityID>(offset);
4078 }
4079
4081 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4082 constexpr
4088
4090 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4091 ONIXS_B3_UMDF_MD_NODISCARD
4092 constexpr
4093 static StrRef securityExchange()
4094 noexcept
4095 {
4096 return constructStrRef("BVMF");
4097 }
4098
4101 ONIXS_B3_UMDF_MD_NODISCARD
4102 MatchEventIndicator matchEventIndicator() const
4103 noexcept
4104 {
4105 constexpr BlockLength offset = 8;
4106
4107 return ordinary<MatchEventIndicator>(offset);
4108 }
4109
4111 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4112 constexpr
4113 static UpdateAction::Enum mDUpdateAction()
4114 noexcept
4115 {
4116 return UpdateAction::NEW;
4117 }
4118
4120 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4121 constexpr
4122 static EntryType::Enum mDEntryType()
4123 noexcept
4124 {
4125 return EntryType::QUANTITY_BAND;
4126 }
4127
4131 ONIXS_B3_UMDF_MD_NODISCARD
4132 bool
4133 avgDailyTradedQty(
4134 QuantityVolumeOptional& value) const
4135 noexcept
4136 {
4137 constexpr BlockLength offset = 12;
4138
4139 return ordinary(value, offset, NullQuantityVolumeOptional());
4140 }
4141
4145 ONIXS_B3_UMDF_MD_NODISCARD
4146 bool
4147 maxTradeVol(
4148 QuantityVolumeOptional& value) const
4149 noexcept
4150 {
4151 constexpr BlockLength offset = 20;
4152
4153 return ordinary(value, offset, NullQuantityVolumeOptional());
4154 }
4155
4157 ONIXS_B3_UMDF_MD_NODISCARD
4158 bool mDEntryTimestamp(UTCTimestampNanos& value) const
4159 noexcept
4160 {
4161 constexpr BlockLength offset = 28;
4162
4163 return ordinary(value, offset, NullUTCTimestampNanos());
4164 }
4165
4168 ONIXS_B3_UMDF_MD_NODISCARD
4169 bool rptSeq(RptSeq& value) const
4170 noexcept
4171 {
4172 constexpr BlockLength offset = 36;
4173
4174 return ordinary(value, offset, NullRptSeq());
4175 }
4176
4178 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4179 constexpr
4180 static
4181 BlockLength
4182 minimalBlockLength(
4183 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4184 noexcept
4185 {
4186 return
4187 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4188 40;
4189 }
4190
4192 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4193 constexpr
4194 static
4195 BlockLength
4196 blockLength(
4197 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4198 noexcept
4199 {
4200 return
4201 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4202 minimalBlockLength(version);
4203 }
4204
4206 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4207 ONIXS_B3_UMDF_MD_NODISCARD
4208 constexpr
4209 static
4210 MessageSize
4211 getMinimalVariableFieldsSize(
4212 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4213 {
4214 return
4215 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4216 0;
4217 }
4218
4220 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4221 ONIXS_B3_UMDF_MD_NODISCARD
4222 constexpr
4223 static StrRef className()
4224 noexcept
4225 {
4226 return constructStrRef("QuantityBand_21");
4227 }
4228
4230 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4231 ONIXS_B3_UMDF_MD_NODISCARD
4232 constexpr
4233 static StrRef fixType()
4234 noexcept
4235 {
4236 return constructStrRef("QuantityBand_21");
4237 }
4238
4240 ONIXS_B3_UMDF_MD_NODISCARD
4241 std::string toString() const;
4242
4243private:
4244 void checkLength(
4245 EncodedLength length, SchemaVersion version) const
4246 {
4247 const EncodedLength minimalRequiredLength =
4248 minimalBlockLength(version) +
4249 MessageHeader::Size +
4250 getMinimalVariableFieldsSize(version);
4251
4252 checkBinaryLength(
4253 *this, length, minimalRequiredLength);
4254 }
4255
4256 void checkCompatibility() const
4257 {
4258 assert(TemplateId == templateId());
4259
4260 checkSchema<Schema>(schemaId(), version());
4261 checkLength(bufferSize(), version());
4262 }
4263};
4264
4266ONIXS_B3_UMDF_MD_LTWT_STRUCT
4267PriceBand_22
4268: SbeMessage
4269{
4271 typedef SchemaTraits Schema;
4272
4274 enum { TemplateId = 22 };
4275
4277 PriceBand_22() = default;
4278
4280 PriceBand_22(
4281 void* data,
4282 EncodedLength length,
4283 NoInit)
4284 : SbeMessage(data, length)
4285 {
4286 checkCompatibility();
4287 }
4288
4290 explicit
4291 PriceBand_22(
4292 const SbeMessage& message)
4293 : SbeMessage(message)
4294 {
4295 assert(message.valid());
4296
4297 checkCompatibility();
4298 }
4299
4302 PriceBand_22(
4303 void* data,
4304 EncodedLength length,
4305 NoInit,
4306 NoCheck)
4307 noexcept
4308 : SbeMessage(data, length, NoCheck())
4309 {
4310 assert(schemaId() == Schema::Id);
4311 assert(version() >= Schema::MinimalVersion);
4312 assert(TemplateId == templateId());
4313 }
4314
4316 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4317 constexpr
4323
4326 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4327 constexpr
4328 static ApplVerID::Enum applVerId()
4329 noexcept
4330 {
4331 return ApplVerID::FIX50SP2;
4332 }
4333
4336 ONIXS_B3_UMDF_MD_NODISCARD
4337 SecurityID securityId() const
4338 noexcept
4339 {
4340 constexpr BlockLength offset = 0;
4341
4342 return ordinary<SecurityID>(offset);
4343 }
4344
4346 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4347 constexpr
4353
4355 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4356 ONIXS_B3_UMDF_MD_NODISCARD
4357 constexpr
4358 static StrRef securityExchange()
4359 noexcept
4360 {
4361 return constructStrRef("BVMF");
4362 }
4363
4366 ONIXS_B3_UMDF_MD_NODISCARD
4367 MatchEventIndicator matchEventIndicator() const
4368 noexcept
4369 {
4370 constexpr BlockLength offset = 8;
4371
4372 return ordinary<MatchEventIndicator>(offset);
4373 }
4374
4376 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4377 constexpr
4378 static UpdateAction::Enum mDUpdateAction()
4379 noexcept
4380 {
4381 return UpdateAction::NEW;
4382 }
4383
4385 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4386 constexpr
4387 static EntryType::Enum mDEntryType()
4388 noexcept
4389 {
4390 return EntryType::PRICE_BAND;
4391 }
4392
4394 ONIXS_B3_UMDF_MD_NODISCARD
4395 bool
4396 priceBandType(
4397 PriceBandType::Enum& value) const
4398 noexcept
4399 {
4400 constexpr BlockLength offset = 9;
4401
4402 return enumeration<PriceBandType>(value, offset, NullUInt8());
4403 }
4404
4406 ONIXS_B3_UMDF_MD_NODISCARD
4407 bool
4408 priceLimitType(
4409 PriceLimitType::Enum& value) const
4410 noexcept
4411 {
4412 constexpr BlockLength offset = 10;
4413
4414 return enumeration<PriceLimitType>(value, offset, NullUInt8());
4415 }
4416
4420 ONIXS_B3_UMDF_MD_NODISCARD
4421 bool
4422 priceBandMidpointPriceType(
4423 PriceBandMidpointPriceType::Enum& value) const
4424 noexcept
4425 {
4426 constexpr BlockLength offset = 11;
4427
4428 return enumeration<PriceBandMidpointPriceType>(value, offset, NullUInt8());
4429 }
4430
4435 ONIXS_B3_UMDF_MD_NODISCARD
4436 bool lowLimitPrice(PriceOptional& value) const
4437 noexcept
4438 {
4439 constexpr BlockLength offset = 12;
4440
4441 return decimal(value, offset, NullPriceOptional());
4442 }
4443
4448 ONIXS_B3_UMDF_MD_NODISCARD
4449 bool highLimitPrice(PriceOptional& value) const
4450 noexcept
4451 {
4452 constexpr BlockLength offset = 20;
4453
4454 return decimal(value, offset, NullPriceOptional());
4455 }
4456
4461 ONIXS_B3_UMDF_MD_NODISCARD
4462 bool tradingReferencePrice(Fixed8& value) const
4463 noexcept
4464 {
4465 constexpr BlockLength offset = 28;
4466
4467 return decimal(value, offset, NullFixed8());
4468 }
4469
4471 ONIXS_B3_UMDF_MD_NODISCARD
4472 bool mDEntryTimestamp(UTCTimestampNanos& value) const
4473 noexcept
4474 {
4475 constexpr BlockLength offset = 36;
4476
4477 return ordinary(value, offset, NullUTCTimestampNanos());
4478 }
4479
4482 ONIXS_B3_UMDF_MD_NODISCARD
4483 bool rptSeq(RptSeq& value) const
4484 noexcept
4485 {
4486 constexpr BlockLength offset = 44;
4487
4488 return ordinary(value, offset, NullRptSeq());
4489 }
4490
4492 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4493 constexpr
4494 static
4495 BlockLength
4496 minimalBlockLength(
4497 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4498 noexcept
4499 {
4500 return
4501 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4502 48;
4503 }
4504
4506 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4507 constexpr
4508 static BlockLength blockLength(SchemaVersion version)
4509 noexcept
4510 {
4511 return
4512 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4513 minimalBlockLength(version);
4514 }
4515
4517 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4518 ONIXS_B3_UMDF_MD_NODISCARD
4519 constexpr
4520 static
4521 MessageSize
4522 getMinimalVariableFieldsSize(
4523 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4524 {
4525 return
4526 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4527 0;
4528 }
4529
4531 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4532 ONIXS_B3_UMDF_MD_NODISCARD
4533 constexpr
4534 static StrRef className()
4535 noexcept
4536 {
4537 return constructStrRef("PriceBand_22");
4538 }
4539
4541 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4542 ONIXS_B3_UMDF_MD_NODISCARD
4543 constexpr
4544 static StrRef fixType()
4545 noexcept
4546 {
4547 return constructStrRef("PriceBand_22");
4548 }
4549
4551 ONIXS_B3_UMDF_MD_NODISCARD
4552 std::string toString() const;
4553
4554private:
4555 void checkLength(
4556 EncodedLength length, SchemaVersion version) const
4557 {
4558 const EncodedLength minimalRequiredLength =
4559 minimalBlockLength(version) +
4560 MessageHeader::Size +
4561 getMinimalVariableFieldsSize(version);
4562
4563 checkBinaryLength(
4564 *this, length, minimalRequiredLength);
4565 }
4566
4567 void checkCompatibility() const
4568 {
4569 assert(TemplateId == templateId());
4570
4571 checkSchema<Schema>(schemaId(), version());
4572 checkLength(bufferSize(), version());
4573 }
4574};
4575
4577ONIXS_B3_UMDF_MD_LTWT_STRUCT
4578HighPrice_24
4579: SbeMessage
4580{
4582 typedef SchemaTraits Schema;
4583
4585 enum { TemplateId = 24 };
4586
4588 HighPrice_24() = default;
4589
4591 HighPrice_24(
4592 void* data,
4593 EncodedLength length,
4594 NoInit)
4595 : SbeMessage(data, length)
4596 {
4597 checkCompatibility();
4598 }
4599
4601 explicit
4602 HighPrice_24(
4603 const SbeMessage& message)
4604 : SbeMessage(message)
4605 {
4606 assert(message.valid());
4607
4608 checkCompatibility();
4609 }
4610
4613 HighPrice_24(
4614 void* data,
4615 EncodedLength length,
4616 NoInit,
4617 NoCheck)
4618 noexcept
4619 : SbeMessage(data, length, NoCheck())
4620 {
4621 assert(schemaId() == Schema::Id);
4622 assert(version() >= Schema::MinimalVersion);
4623 assert(TemplateId == templateId());
4624 }
4625
4627 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4628 constexpr
4634
4637 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4638 constexpr
4639 static ApplVerID::Enum applVerId()
4640 noexcept
4641 {
4642 return ApplVerID::FIX50SP2;
4643 }
4644
4647 ONIXS_B3_UMDF_MD_NODISCARD
4648 SecurityID securityId() const
4649 noexcept
4650 {
4651 constexpr BlockLength offset = 0;
4652
4653 return ordinary<SecurityID>(offset);
4654 }
4655
4657 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4658 constexpr
4664
4666 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4667 ONIXS_B3_UMDF_MD_NODISCARD
4668 constexpr
4669 static StrRef securityExchange()
4670 noexcept
4671 {
4672 return constructStrRef("BVMF");
4673 }
4674
4677 ONIXS_B3_UMDF_MD_NODISCARD
4678 MatchEventIndicator matchEventIndicator() const
4679 noexcept
4680 {
4681 constexpr BlockLength offset = 8;
4682
4683 return ordinary<MatchEventIndicator>(offset);
4684 }
4685
4687 ONIXS_B3_UMDF_MD_NODISCARD
4688 UpdateAction::Enum mDUpdateAction() const
4689 noexcept
4690 {
4691 constexpr BlockLength offset = 9;
4692
4693 return enumeration<UpdateAction>(offset);
4694 }
4695
4697 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4698 constexpr
4699 static EntryType::Enum mDEntryType()
4700 noexcept
4701 {
4702 return EntryType::SESSION_HIGH_PRICE;
4703 }
4704
4707 ONIXS_B3_UMDF_MD_NODISCARD
4708 Timestamp tradeDate() const
4709 noexcept
4710 {
4711 constexpr BlockLength offset = 10;
4712
4713 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
4714 }
4715
4717 ONIXS_B3_UMDF_MD_NODISCARD
4718 Price mDEntryPx() const
4719 noexcept
4720 {
4721 constexpr BlockLength offset = 12;
4722
4723 return decimal<Price>(offset);
4724 }
4725
4727 ONIXS_B3_UMDF_MD_NODISCARD
4728 bool mDEntryTimestamp(UTCTimestampNanos& value) const
4729 noexcept
4730 {
4731 constexpr BlockLength offset = 20;
4732
4733 return ordinary(value, offset, NullUTCTimestampNanos());
4734 }
4735
4738 ONIXS_B3_UMDF_MD_NODISCARD
4739 bool rptSeq(RptSeq& value) const
4740 noexcept
4741 {
4742 constexpr BlockLength offset = 28;
4743
4744 return ordinary(value, offset, NullRptSeq());
4745 }
4746
4748 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4749 constexpr
4750 static
4751 BlockLength
4752 minimalBlockLength(
4753 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4754 noexcept
4755 {
4756 return
4757 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4758 32;
4759 }
4760
4762 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4763 constexpr
4764 static BlockLength blockLength(SchemaVersion version)
4765 noexcept
4766 {
4767 return
4768 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4769 minimalBlockLength(version);
4770 }
4771
4773 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4774 ONIXS_B3_UMDF_MD_NODISCARD
4775 constexpr
4776 static
4777 MessageSize
4778 getMinimalVariableFieldsSize(
4779 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4780 {
4781 return
4782 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4783 0;
4784 }
4785
4787 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4788 ONIXS_B3_UMDF_MD_NODISCARD
4789 constexpr
4790 static StrRef className()
4791 noexcept
4792 {
4793 return constructStrRef("HighPrice_24");
4794 }
4795
4797 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4798 ONIXS_B3_UMDF_MD_NODISCARD
4799 constexpr
4800 static StrRef fixType()
4801 noexcept
4802 {
4803 return constructStrRef("HighPrice_24");
4804 }
4805
4807 ONIXS_B3_UMDF_MD_NODISCARD
4808 std::string toString() const;
4809
4810private:
4811 void checkLength(
4812 EncodedLength length, SchemaVersion version) const
4813 {
4814 const EncodedLength minimalRequiredLength =
4815 minimalBlockLength(version) +
4816 MessageHeader::Size +
4817 getMinimalVariableFieldsSize(version);
4818
4819 checkBinaryLength(
4820 *this, length, minimalRequiredLength);
4821 }
4822
4823 void checkCompatibility() const
4824 {
4825 assert(TemplateId == templateId());
4826
4827 checkSchema<Schema>(schemaId(), version());
4828 checkLength(bufferSize(), version());
4829 }
4830};
4831
4833ONIXS_B3_UMDF_MD_LTWT_STRUCT
4834LowPrice_25
4835: SbeMessage
4836{
4838 typedef SchemaTraits Schema;
4839
4841 enum { TemplateId = 25 };
4842
4844 LowPrice_25() = default;
4845
4847 LowPrice_25(
4848 void* data,
4849 EncodedLength length,
4850 NoInit)
4851 : SbeMessage(data, length)
4852 {
4853 checkCompatibility();
4854 }
4855
4857 explicit
4858 LowPrice_25(
4859 const SbeMessage& message)
4860 : SbeMessage(message)
4861 {
4862 assert(message.valid());
4863
4864 checkCompatibility();
4865 }
4866
4869 LowPrice_25(
4870 void* data,
4871 EncodedLength length,
4872 NoInit,
4873 NoCheck)
4874 noexcept
4875 : SbeMessage(data, length, NoCheck())
4876 {
4877 assert(schemaId() == Schema::Id);
4878 assert(version() >= Schema::MinimalVersion);
4879 assert(TemplateId == templateId());
4880 }
4881
4883 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4884 constexpr
4890
4893 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4894 constexpr
4895 static ApplVerID::Enum applVerId()
4896 noexcept
4897 {
4898 return ApplVerID::FIX50SP2;
4899 }
4900
4903 ONIXS_B3_UMDF_MD_NODISCARD
4904 SecurityID securityId() const
4905 noexcept
4906 {
4907 constexpr BlockLength offset = 0;
4908
4909 return ordinary<SecurityID>(offset);
4910 }
4911
4913 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4914 constexpr
4920
4922 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4923 ONIXS_B3_UMDF_MD_NODISCARD
4924 constexpr
4925 static StrRef securityExchange()
4926 noexcept
4927 {
4928 return constructStrRef("BVMF");
4929 }
4930
4933 ONIXS_B3_UMDF_MD_NODISCARD
4934 MatchEventIndicator matchEventIndicator() const
4935 noexcept
4936 {
4937 constexpr BlockLength offset = 8;
4938
4939 return ordinary<MatchEventIndicator>(offset);
4940 }
4941
4943 ONIXS_B3_UMDF_MD_NODISCARD
4944 UpdateAction::Enum mDUpdateAction() const
4945 noexcept
4946 {
4947 constexpr BlockLength offset = 9;
4948
4949 return enumeration<UpdateAction>(offset);
4950 }
4951
4953 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4954 constexpr
4955 static EntryType::Enum mDEntryType()
4956 noexcept
4957 {
4958 return EntryType::SESSION_LOW_PRICE;
4959 }
4960
4963 ONIXS_B3_UMDF_MD_NODISCARD
4964 Timestamp tradeDate() const
4965 noexcept
4966 {
4967 constexpr BlockLength offset = 10;
4968
4969 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
4970 }
4971
4973 ONIXS_B3_UMDF_MD_NODISCARD
4974 Price mDEntryPx() const
4975 noexcept
4976 {
4977 constexpr BlockLength offset = 12;
4978
4979 return decimal<Price>(offset);
4980 }
4981
4983 ONIXS_B3_UMDF_MD_NODISCARD
4984 bool mDEntryTimestamp(UTCTimestampNanos& value) const
4985 noexcept
4986 {
4987 constexpr BlockLength offset = 20;
4988
4989 return ordinary(value, offset, NullUTCTimestampNanos());
4990 }
4991
4994 ONIXS_B3_UMDF_MD_NODISCARD
4995 bool rptSeq(RptSeq& value) const
4996 noexcept
4997 {
4998 constexpr BlockLength offset = 28;
4999
5000 return ordinary(value, offset, NullRptSeq());
5001 }
5002
5004 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5005 constexpr
5006 static
5007 BlockLength
5008 minimalBlockLength(
5009 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5010 noexcept
5011 {
5012 return
5013 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5014 32;
5015 }
5016
5018 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5019 constexpr
5020 static BlockLength blockLength(SchemaVersion version)
5021 noexcept
5022 {
5023 return
5024 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5025 minimalBlockLength(version);
5026 }
5027
5029 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5030 ONIXS_B3_UMDF_MD_NODISCARD
5031 constexpr
5032 static
5033 MessageSize
5034 getMinimalVariableFieldsSize(
5035 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5036 {
5037 return
5038 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5039 0;
5040 }
5041
5043 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5044 ONIXS_B3_UMDF_MD_NODISCARD
5045 constexpr
5046 static StrRef className()
5047 noexcept
5048 {
5049 return constructStrRef("LowPrice_25");
5050 }
5051
5053 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5054 ONIXS_B3_UMDF_MD_NODISCARD
5055 constexpr
5056 static StrRef fixType()
5057 noexcept
5058 {
5059 return constructStrRef("LowPrice_25");
5060 }
5061
5063 ONIXS_B3_UMDF_MD_NODISCARD
5064 std::string toString() const;
5065
5066private:
5067 void checkLength(
5068 EncodedLength length, SchemaVersion version) const
5069 {
5070 const EncodedLength minimalRequiredLength =
5071 minimalBlockLength(version) +
5072 MessageHeader::Size +
5073 getMinimalVariableFieldsSize(version);
5074
5075 checkBinaryLength(
5076 *this, length, minimalRequiredLength);
5077 }
5078
5079 void checkCompatibility() const
5080 {
5081 assert(TemplateId == templateId());
5082
5083 checkSchema<Schema>(schemaId(), version());
5084 checkLength(bufferSize(), version());
5085 }
5086};
5087
5089ONIXS_B3_UMDF_MD_LTWT_STRUCT
5090LastTradePrice_27
5091: SbeMessage
5092{
5094 typedef SchemaTraits Schema;
5095
5097 enum { TemplateId = 27 };
5098
5100 LastTradePrice_27() = default;
5101
5103 LastTradePrice_27(
5104 void* data,
5105 EncodedLength length,
5106 NoInit)
5107 : SbeMessage(data, length)
5108 {
5109 checkCompatibility();
5110 }
5111
5113 explicit
5114 LastTradePrice_27(
5115 const SbeMessage& message)
5116 : SbeMessage(message)
5117 {
5118 assert(message.valid());
5119
5120 checkCompatibility();
5121 }
5122
5125 LastTradePrice_27(
5126 void* data,
5127 EncodedLength length,
5128 NoInit,
5129 NoCheck)
5130 noexcept
5131 : SbeMessage(data, length, NoCheck())
5132 {
5133 assert(schemaId() == Schema::Id);
5134 assert(version() >= Schema::MinimalVersion);
5135 assert(TemplateId == templateId());
5136 }
5137
5139 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5140 constexpr
5146
5149 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5150 constexpr
5151 static ApplVerID::Enum applVerId()
5152 noexcept
5153 {
5154 return ApplVerID::FIX50SP2;
5155 }
5156
5159 ONIXS_B3_UMDF_MD_NODISCARD
5160 SecurityID securityId() const
5161 noexcept
5162 {
5163 constexpr BlockLength offset = 0;
5164
5165 return ordinary<SecurityID>(offset);
5166 }
5167
5169 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5170 constexpr
5176
5178 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5179 ONIXS_B3_UMDF_MD_NODISCARD
5180 constexpr
5181 static StrRef securityExchange()
5182 noexcept
5183 {
5184 return constructStrRef("BVMF");
5185 }
5186
5189 ONIXS_B3_UMDF_MD_NODISCARD
5190 MatchEventIndicator matchEventIndicator() const
5191 noexcept
5192 {
5193 constexpr BlockLength offset = 8;
5194
5195 return ordinary<MatchEventIndicator>(offset);
5196 }
5197
5199 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5200 constexpr
5201 static UpdateAction::Enum mDUpdateAction()
5202 noexcept
5203 {
5204 return UpdateAction::NEW;
5205 }
5206
5208 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5209 constexpr
5210 static EntryType::Enum mDEntryType()
5211 noexcept
5212 {
5213 return EntryType::TRADE;
5214 }
5215
5217 ONIXS_B3_UMDF_MD_NODISCARD
5218 TradingSessionID::Enum tradingSessionId() const
5219 noexcept
5220 {
5221 constexpr BlockLength offset = 9;
5222
5223 return enumeration<TradingSessionID>(offset);
5224 }
5225
5227 ONIXS_B3_UMDF_MD_NODISCARD
5228 TradeCondition tradeCondition() const
5229 noexcept
5230 {
5231 constexpr BlockLength offset = 10;
5232
5233 return ordinary<TradeCondition>(offset);
5234 }
5235
5237 ONIXS_B3_UMDF_MD_NODISCARD
5238 Price mDEntryPx() const
5239 noexcept
5240 {
5241 constexpr BlockLength offset = 12;
5242
5243 return decimal<Price>(offset);
5244 }
5245
5247 ONIXS_B3_UMDF_MD_NODISCARD
5248 Quantity mDEntrySize() const
5249 noexcept
5250 {
5251 constexpr BlockLength offset = 20;
5252
5253 return ordinary<Quantity>(offset);
5254 }
5255
5259 ONIXS_B3_UMDF_MD_NODISCARD
5260 TradeID tradeId() const
5261 noexcept
5262 {
5263 constexpr BlockLength offset = 28;
5264
5265 return ordinary<TradeID>(offset);
5266 }
5267
5269 ONIXS_B3_UMDF_MD_NODISCARD
5270 bool mDEntryBuyer(FirmOptional& value) const
5271 noexcept
5272 {
5273 constexpr BlockLength offset = 32;
5274
5275 return ordinary(value, offset, NullFirmOptional());
5276 }
5277
5279 ONIXS_B3_UMDF_MD_NODISCARD
5280 bool mDEntrySeller(FirmOptional& value) const
5281 noexcept
5282 {
5283 constexpr BlockLength offset = 36;
5284
5285 return ordinary(value, offset, NullFirmOptional());
5286 }
5287
5290 ONIXS_B3_UMDF_MD_NODISCARD
5291 Timestamp tradeDate() const
5292 noexcept
5293 {
5294 constexpr BlockLength offset = 40;
5295
5296 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
5297 }
5298
5300 ONIXS_B3_UMDF_MD_NODISCARD
5301 bool mDEntryTimestamp(UTCTimestampNanos& value) const
5302 noexcept
5303 {
5304 constexpr BlockLength offset = 42;
5305
5306 return ordinary(value, offset, NullUTCTimestampNanos());
5307 }
5308
5311 ONIXS_B3_UMDF_MD_NODISCARD
5312 bool rptSeq(RptSeq& value) const
5313 noexcept
5314 {
5315 constexpr BlockLength offset = 50;
5316
5317 return ordinary(value, offset, NullRptSeq());
5318 }
5319
5323 ONIXS_B3_UMDF_MD_NODISCARD
5324 bool sellerDays(UInt16NULL& value) const
5325 noexcept
5326 {
5327 constexpr BlockLength offset = 54;
5328
5329 return ordinary(value, offset, NullUInt16NULL());
5330 }
5331
5335 ONIXS_B3_UMDF_MD_NODISCARD
5336 bool mDEntryInterestRate(Percentage& value) const
5337 noexcept
5338 {
5339 constexpr BlockLength offset = 56;
5340
5341 return decimal(value, offset, NullPercentage());
5342 }
5343
5345 ONIXS_B3_UMDF_MD_NODISCARD
5346 bool trdSubType(TrdSubType::Enum& value) const
5347 noexcept
5348 {
5349 constexpr BlockLength offset = 64;
5350
5351 return enumeration<TrdSubType>(value, offset, NullUInt8NULL());
5352 }
5353
5355 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5356 constexpr
5357 static
5358 BlockLength
5359 minimalBlockLength(
5360 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5361 noexcept
5362 {
5363 return
5364 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5365 68;
5366 }
5367
5369 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5370 constexpr
5371 static
5372 BlockLength
5373 blockLength(
5374 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5375 noexcept
5376 {
5377 return
5378 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5379 68;
5380 }
5381
5383 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5384 ONIXS_B3_UMDF_MD_NODISCARD
5385 constexpr
5386 static
5387 MessageSize
5388 getMinimalVariableFieldsSize(
5389 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5390 {
5391 return
5392 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5393 0;
5394 }
5395
5397 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5398 ONIXS_B3_UMDF_MD_NODISCARD
5399 constexpr
5400 static StrRef className()
5401 noexcept
5402 {
5403 return constructStrRef("LastTradePrice_27");
5404 }
5405
5407 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5408 ONIXS_B3_UMDF_MD_NODISCARD
5409 constexpr
5410 static StrRef fixType()
5411 noexcept
5412 {
5413 return constructStrRef("LastTradePrice_27");
5414 }
5415
5417 ONIXS_B3_UMDF_MD_NODISCARD
5418 std::string toString() const;
5419
5420private:
5421 void checkLength(
5422 EncodedLength length, SchemaVersion version) const
5423 {
5424 const EncodedLength minimalRequiredLength =
5425 minimalBlockLength(version) +
5426 MessageHeader::Size +
5427 getMinimalVariableFieldsSize(version);
5428
5429 checkBinaryLength(
5430 *this, length, minimalRequiredLength);
5431 }
5432
5433 void checkCompatibility() const
5434 {
5435 assert(TemplateId == templateId());
5436
5437 checkSchema<Schema>(schemaId(), version());
5438 checkLength(bufferSize(), version());
5439 }
5440};
5441
5443ONIXS_B3_UMDF_MD_LTWT_STRUCT
5444SettlementPrice_28
5445: SbeMessage
5446{
5448 typedef SchemaTraits Schema;
5449
5451 enum { TemplateId = 28 };
5452
5454 SettlementPrice_28() = default;
5455
5457 SettlementPrice_28(
5458 void* data,
5459 EncodedLength length,
5460 NoInit)
5461 : SbeMessage(data, length)
5462 {
5463 checkCompatibility();
5464 }
5465
5467 explicit
5468 SettlementPrice_28(
5469 const SbeMessage& message)
5470 : SbeMessage(message)
5471 {
5472 assert(message.valid());
5473
5474 checkCompatibility();
5475 }
5476
5479 SettlementPrice_28(
5480 void* data,
5481 EncodedLength length,
5482 NoInit,
5483 NoCheck)
5484 noexcept
5485 : SbeMessage(data, length, NoCheck())
5486 {
5487 assert(schemaId() == Schema::Id);
5488 assert(version() >= Schema::MinimalVersion);
5489 assert(TemplateId == templateId());
5490 }
5491
5493 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5494 constexpr
5500
5503 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5504 constexpr
5505 static ApplVerID::Enum applVerId()
5506 noexcept
5507 {
5508 return ApplVerID::FIX50SP2;
5509 }
5510
5513 ONIXS_B3_UMDF_MD_NODISCARD
5514 SecurityID securityId() const
5515 noexcept
5516 {
5517 constexpr BlockLength offset = 0;
5518
5519 return ordinary<SecurityID>(offset);
5520 }
5521
5523 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5524 constexpr
5530
5532 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5533 ONIXS_B3_UMDF_MD_NODISCARD
5534 constexpr
5535 static StrRef securityExchange()
5536 noexcept
5537 {
5538 return constructStrRef("BVMF");
5539 }
5540
5543 ONIXS_B3_UMDF_MD_NODISCARD
5544 MatchEventIndicator matchEventIndicator() const
5545 noexcept
5546 {
5547 constexpr BlockLength offset = 8;
5548
5549 return ordinary<MatchEventIndicator>(offset);
5550 }
5551
5553 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5554 constexpr
5555 static UpdateAction::Enum mDUpdateAction()
5556 noexcept
5557 {
5558 return UpdateAction::NEW;
5559 }
5560
5562 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5563 constexpr
5564 static EntryType::Enum mDEntryType()
5565 noexcept
5566 {
5567 return EntryType::SETTLEMENT_PRICE;
5568 }
5569
5572 ONIXS_B3_UMDF_MD_NODISCARD
5573 Timestamp tradeDate() const
5574 noexcept
5575 {
5576 constexpr BlockLength offset = 10;
5577
5578 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
5579 }
5580
5582 ONIXS_B3_UMDF_MD_NODISCARD
5583 Price mDEntryPx() const
5584 noexcept
5585 {
5586 constexpr BlockLength offset = 12;
5587
5588 return decimal<Price>(offset);
5589 }
5590
5592 ONIXS_B3_UMDF_MD_NODISCARD
5593 bool mDEntryTimestamp(UTCTimestampNanos& value) const
5594 noexcept
5595 {
5596 constexpr BlockLength offset = 20;
5597
5598 return ordinary(value, offset, NullUTCTimestampNanos());
5599 }
5600
5603 ONIXS_B3_UMDF_MD_NODISCARD
5604 OpenCloseSettlFlag::Enum openCloseSettlFlag() const
5605 noexcept
5606 {
5607 constexpr BlockLength offset = 28;
5608
5609 return enumeration<OpenCloseSettlFlag>(offset);
5610 }
5611
5613 ONIXS_B3_UMDF_MD_NODISCARD
5614 bool priceType(PriceType::Enum& value) const
5615 noexcept
5616 {
5617 constexpr BlockLength offset = 29;
5618
5619 return enumeration<PriceType>(value, offset, NullUInt8NULL());
5620 }
5621
5623 ONIXS_B3_UMDF_MD_NODISCARD
5624 SettlPriceType::Enum settlPriceType() const
5625 noexcept
5626 {
5627 constexpr BlockLength offset = 30;
5628
5629 return enumeration<SettlPriceType>(offset);
5630 }
5631
5634 ONIXS_B3_UMDF_MD_NODISCARD
5635 bool rptSeq(RptSeq& value) const
5636 noexcept
5637 {
5638 constexpr BlockLength offset = 31;
5639
5640 return ordinary(value, offset, NullRptSeq());
5641 }
5642
5644 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5645 constexpr
5646 static
5647 BlockLength
5648 minimalBlockLength(
5649 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5650 noexcept
5651 {
5652 return
5653 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5654 36;
5655 }
5656
5658 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5659 constexpr
5660 static
5661 BlockLength
5662 blockLength(
5663 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5664 noexcept
5665 {
5666 return
5667 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5668 36;
5669 }
5670
5672 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5673 ONIXS_B3_UMDF_MD_NODISCARD
5674 constexpr
5675 static
5676 MessageSize
5677 getMinimalVariableFieldsSize(
5678 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5679 {
5680 return
5681 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5682 0;
5683 }
5684
5686 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5687 ONIXS_B3_UMDF_MD_NODISCARD
5688 constexpr
5689 static StrRef className()
5690 noexcept
5691 {
5692 return constructStrRef("SettlementPrice_28");
5693 }
5694
5696 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5697 ONIXS_B3_UMDF_MD_NODISCARD
5698 constexpr
5699 static StrRef fixType()
5700 noexcept
5701 {
5702 return constructStrRef("SettlementPrice_28");
5703 }
5704
5706 ONIXS_B3_UMDF_MD_NODISCARD
5707 std::string toString() const;
5708
5709private:
5710 void checkLength(
5711 EncodedLength length, SchemaVersion version) const
5712 {
5713 const EncodedLength minimalRequiredLength =
5714 minimalBlockLength(version) +
5715 MessageHeader::Size +
5716 getMinimalVariableFieldsSize(version);
5717
5718 checkBinaryLength(
5719 *this, length, minimalRequiredLength);
5720 }
5721
5722 void checkCompatibility() const
5723 {
5724 assert(TemplateId == templateId());
5725
5726 checkSchema<Schema>(schemaId(), version());
5727 checkLength(bufferSize(), version());
5728 }
5729};
5730
5732ONIXS_B3_UMDF_MD_LTWT_STRUCT
5733OpenInterest_29
5734: SbeMessage
5735{
5737 typedef SchemaTraits Schema;
5738
5740 enum { TemplateId = 29 };
5741
5743 OpenInterest_29() = default;
5744
5746 OpenInterest_29(
5747 void* data,
5748 EncodedLength length,
5749 NoInit)
5750 : SbeMessage(data, length)
5751 {
5752 checkCompatibility();
5753 }
5754
5756 explicit
5757 OpenInterest_29(
5758 const SbeMessage& message)
5759 : SbeMessage(message)
5760 {
5761 assert(message.valid());
5762
5763 checkCompatibility();
5764 }
5765
5768 OpenInterest_29(
5769 void* data,
5770 EncodedLength length,
5771 NoInit,
5772 NoCheck)
5773 noexcept
5774 : SbeMessage(data, length, NoCheck())
5775 {
5776 assert(schemaId() == Schema::Id);
5777 assert(version() >= Schema::MinimalVersion);
5778 assert(TemplateId == templateId());
5779 }
5780
5782 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5783 constexpr
5789
5792 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5793 constexpr
5794 static ApplVerID::Enum applVerId()
5795 noexcept
5796 {
5797 return ApplVerID::FIX50SP2;
5798 }
5799
5802 ONIXS_B3_UMDF_MD_NODISCARD
5803 SecurityID securityId() const
5804 noexcept
5805 {
5806 constexpr BlockLength offset = 0;
5807
5808 return ordinary<SecurityID>(offset);
5809 }
5810
5812 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5813 constexpr
5819
5821 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5822 ONIXS_B3_UMDF_MD_NODISCARD
5823 constexpr
5824 static StrRef securityExchange()
5825 noexcept
5826 {
5827 return constructStrRef("BVMF");
5828 }
5829
5832 ONIXS_B3_UMDF_MD_NODISCARD
5833 MatchEventIndicator matchEventIndicator() const
5834 noexcept
5835 {
5836 constexpr BlockLength offset = 8;
5837
5838 return ordinary<MatchEventIndicator>(offset);
5839 }
5840
5842 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5843 constexpr
5844 static UpdateAction::Enum mDUpdateAction()
5845 noexcept
5846 {
5847 return UpdateAction::NEW;
5848 }
5849
5851 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5852 constexpr
5853 static EntryType::Enum mDEntryType()
5854 noexcept
5855 {
5856 return EntryType::OPEN_INTEREST;
5857 }
5858
5861 ONIXS_B3_UMDF_MD_NODISCARD
5862 Timestamp tradeDate() const
5863 noexcept
5864 {
5865 constexpr BlockLength offset = 10;
5866
5867 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
5868 }
5869
5871 ONIXS_B3_UMDF_MD_NODISCARD
5872 Quantity mDEntrySize() const
5873 noexcept
5874 {
5875 constexpr BlockLength offset = 12;
5876
5877 return ordinary<Quantity>(offset);
5878 }
5879
5881 ONIXS_B3_UMDF_MD_NODISCARD
5882 bool mDEntryTimestamp(UTCTimestampNanos& value) const
5883 noexcept
5884 {
5885 constexpr BlockLength offset = 20;
5886
5887 return ordinary(value, offset, NullUTCTimestampNanos());
5888 }
5889
5892 ONIXS_B3_UMDF_MD_NODISCARD
5893 bool rptSeq(RptSeq& value) const
5894 noexcept
5895 {
5896 constexpr BlockLength offset = 28;
5897
5898 return ordinary(value, offset, NullRptSeq());
5899 }
5900
5902 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5903 constexpr
5904 static
5905 BlockLength
5906 minimalBlockLength(
5907 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5908 noexcept
5909 {
5910 return
5911 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5912 32;
5913 }
5914
5916 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5917 constexpr
5918 static
5919 BlockLength
5920 blockLength(
5921 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5922 noexcept
5923 {
5924 return
5925 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5926 32;
5927 }
5928
5930 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5931 ONIXS_B3_UMDF_MD_NODISCARD
5932 constexpr
5933 static
5934 MessageSize
5935 getMinimalVariableFieldsSize(
5936 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5937 {
5938 return
5939 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5940 0;
5941 }
5942
5944 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5945 ONIXS_B3_UMDF_MD_NODISCARD
5946 constexpr
5947 static StrRef className()
5948 noexcept
5949 {
5950 return constructStrRef("OpenInterest_29");
5951 }
5952
5954 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5955 ONIXS_B3_UMDF_MD_NODISCARD
5956 constexpr
5957 static StrRef fixType()
5958 noexcept
5959 {
5960 return constructStrRef("OpenInterest_29");
5961 }
5962
5964 ONIXS_B3_UMDF_MD_NODISCARD
5965 std::string toString() const;
5966
5967private:
5968 void checkLength(
5969 EncodedLength length, SchemaVersion version) const
5970 {
5971 const EncodedLength minimalRequiredLength =
5972 minimalBlockLength(version) +
5973 MessageHeader::Size +
5974 getMinimalVariableFieldsSize(version);
5975
5976 checkBinaryLength(
5977 *this, length, minimalRequiredLength);
5978 }
5979
5980 void checkCompatibility() const
5981 {
5982 assert(TemplateId == templateId());
5983
5984 checkSchema<Schema>(schemaId(), version());
5985 checkLength(bufferSize(), version());
5986 }
5987};
5988
5990ONIXS_B3_UMDF_MD_LTWT_STRUCT
5991SnapshotFullRefresh_Header_30
5992: SbeMessage
5993{
5995 typedef SchemaTraits Schema;
5996
5998 enum { TemplateId = 30 };
5999
6001 SnapshotFullRefresh_Header_30() = default;
6002
6004 SnapshotFullRefresh_Header_30(
6005 void* data,
6006 EncodedLength length,
6007 NoInit)
6008 : SbeMessage(data, length)
6009 {
6010 checkCompatibility();
6011 }
6012
6014 explicit
6015 SnapshotFullRefresh_Header_30(
6016 const SbeMessage& message)
6017 : SbeMessage(message)
6018 {
6019 assert(message.valid());
6020
6021 checkCompatibility();
6022 }
6023
6026 SnapshotFullRefresh_Header_30(
6027 void* data,
6028 EncodedLength length,
6029 NoInit,
6030 NoCheck)
6031 noexcept
6032 : SbeMessage(data, length, NoCheck())
6033 {
6034 assert(schemaId() == Schema::Id);
6035 assert(version() >= Schema::MinimalVersion);
6036 assert(TemplateId == templateId());
6037 }
6038
6040 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6041 constexpr
6047
6050 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6051 constexpr
6052 static ApplVerID::Enum applVerId()
6053 noexcept
6054 {
6055 return ApplVerID::FIX50SP2;
6056 }
6057
6060 ONIXS_B3_UMDF_MD_NODISCARD
6061 SecurityID securityId() const
6062 noexcept
6063 {
6064 constexpr BlockLength offset = 0;
6065
6066 return ordinary<SecurityID>(offset);
6067 }
6068
6070 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6071 constexpr
6077
6079 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6080 ONIXS_B3_UMDF_MD_NODISCARD
6081 constexpr
6082 static StrRef securityExchange()
6083 noexcept
6084 {
6085 return constructStrRef("BVMF");
6086 }
6087
6092 ONIXS_B3_UMDF_MD_NODISCARD
6093 SeqNum lastMsgSeqNumProcessed() const
6094 noexcept
6095 {
6096 constexpr BlockLength offset = 8;
6097
6098 return ordinary<SeqNum>(offset);
6099 }
6100
6103 ONIXS_B3_UMDF_MD_NODISCARD
6104 UInt32 totNumReports() const
6105 noexcept
6106 {
6107 constexpr BlockLength offset = 12;
6108
6109 return ordinary<UInt32>(offset);
6110 }
6111
6113 ONIXS_B3_UMDF_MD_NODISCARD
6114 UInt32 totNumBids() const
6115 noexcept
6116 {
6117 constexpr BlockLength offset = 16;
6118
6119 return ordinary<UInt32>(offset);
6120 }
6121
6123 ONIXS_B3_UMDF_MD_NODISCARD
6124 UInt32 totNumOffers() const
6125 noexcept
6126 {
6127 constexpr BlockLength offset = 20;
6128
6129 return ordinary<UInt32>(offset);
6130 }
6131
6134 ONIXS_B3_UMDF_MD_NODISCARD
6135 UInt16 totNumStats() const
6136 noexcept
6137 {
6138 constexpr BlockLength offset = 24;
6139
6140 return ordinary<UInt16>(offset);
6141 }
6142
6147 ONIXS_B3_UMDF_MD_NODISCARD
6148 bool lastRptSeq(RptSeq& value) const
6149 noexcept
6150 {
6151 constexpr BlockLength offset = 28;
6152
6153 return ordinary(value, offset, NullRptSeq());
6154 }
6155
6160 ONIXS_B3_UMDF_MD_NODISCARD
6161 bool lastSequenceVersion(UInt16NULL& value) const
6162 noexcept
6163 {
6164 constexpr BlockLength offset = 32;
6165
6166 return ordinary(value, offset, NullUInt16NULL());
6167 }
6168
6170 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6171 constexpr
6172 static
6173 BlockLength
6174 minimalBlockLength(
6175 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6176 noexcept
6177 {
6178 return
6179 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6180 34;
6181 }
6182
6184 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6185 constexpr
6186 static
6187 BlockLength
6188 blockLength(
6189 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6190 noexcept
6191 {
6192 return
6193 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6194 minimalBlockLength(version);
6195 }
6196
6198 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6199 ONIXS_B3_UMDF_MD_NODISCARD
6200 constexpr
6201 static
6202 MessageSize
6203 getMinimalVariableFieldsSize(
6204 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6205 {
6206 return
6207 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6208 0;
6209 }
6210
6212 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6213 ONIXS_B3_UMDF_MD_NODISCARD
6214 constexpr
6215 static StrRef className()
6216 noexcept
6217 {
6218 return constructStrRef("SnapshotFullRefresh_Header_30");
6219 }
6220
6222 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6223 ONIXS_B3_UMDF_MD_NODISCARD
6224 constexpr
6225 static StrRef fixType()
6226 noexcept
6227 {
6228 return constructStrRef(
6229 "SnapshotFullRefresh_Header_30");
6230 }
6231
6233 ONIXS_B3_UMDF_MD_NODISCARD
6234 std::string toString() const;
6235
6236private:
6237 void checkLength(
6238 EncodedLength length, SchemaVersion version) const
6239 {
6240 const EncodedLength minimalRequiredLength =
6241 minimalBlockLength(version) +
6242 MessageHeader::Size +
6243 getMinimalVariableFieldsSize(version);
6244
6245 checkBinaryLength(
6246 *this, length, minimalRequiredLength);
6247 }
6248
6249 void checkCompatibility() const
6250 {
6251 assert(TemplateId == templateId());
6252
6253 checkSchema<Schema>(schemaId(), version());
6254 checkLength(bufferSize(), version());
6255 }
6256};
6257
6259ONIXS_B3_UMDF_MD_LTWT_STRUCT
6260Order_MBO_50
6261: SbeMessage
6262{
6264 typedef SchemaTraits Schema;
6265
6267 enum { TemplateId = 50 };
6268
6270 Order_MBO_50() = default;
6271
6273 Order_MBO_50(
6274 void* data,
6275 EncodedLength length,
6276 NoInit)
6277 : SbeMessage(data, length)
6278 {
6279 checkCompatibility();
6280 }
6281
6283 explicit
6284 Order_MBO_50(
6285 const SbeMessage& message)
6286 : SbeMessage(message)
6287 {
6288 assert(message.valid());
6289
6290 checkCompatibility();
6291 }
6292
6295 Order_MBO_50(
6296 void* data,
6297 EncodedLength length,
6298 NoInit,
6299 NoCheck)
6300 noexcept
6301 : SbeMessage(data, length, NoCheck())
6302 {
6303 assert(schemaId() == Schema::Id);
6304 assert(version() >= Schema::MinimalVersion);
6305 assert(TemplateId == templateId());
6306 }
6307
6309 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6310 constexpr
6316
6319 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6320 constexpr
6321 static ApplVerID::Enum applVerId()
6322 noexcept
6323 {
6324 return ApplVerID::FIX50SP2;
6325 }
6326
6329 ONIXS_B3_UMDF_MD_NODISCARD
6330 SecurityID securityId() const
6331 noexcept
6332 {
6333 constexpr BlockLength offset = 0;
6334
6335 return ordinary<SecurityID>(offset);
6336 }
6337
6339 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6340 constexpr
6346
6348 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6349 ONIXS_B3_UMDF_MD_NODISCARD
6350 constexpr
6351 static StrRef securityExchange()
6352 noexcept
6353 {
6354 return constructStrRef("BVMF");
6355 }
6356
6360 ONIXS_B3_UMDF_MD_NODISCARD
6361 MatchEventIndicator matchEventIndicator() const
6362 noexcept
6363 {
6364 constexpr BlockLength offset = 8;
6365
6366 return ordinary<MatchEventIndicator>(offset);
6367 }
6368
6370 ONIXS_B3_UMDF_MD_NODISCARD
6371 UpdateAction::Enum mDUpdateAction() const
6372 noexcept
6373 {
6374 constexpr BlockLength offset = 9;
6375
6376 return enumeration<UpdateAction>(offset);
6377 }
6378
6380 ONIXS_B3_UMDF_MD_NODISCARD
6381 EntryType::Enum mDEntryType() const
6382 noexcept
6383 {
6384 constexpr BlockLength offset = 10;
6385
6386 return enumeration<EntryType>(offset);
6387 }
6388
6391 ONIXS_B3_UMDF_MD_NODISCARD
6392 bool mDEntryPx(PriceOptional& value) const
6393 noexcept
6394 {
6395 constexpr BlockLength offset = 12;
6396
6397 return decimal(value, offset, NullPriceOptional());
6398 }
6399
6402 ONIXS_B3_UMDF_MD_NODISCARD
6403 Quantity mDEntrySize() const
6404 noexcept
6405 {
6406 constexpr BlockLength offset = 20;
6407
6408 return ordinary<Quantity>(offset);
6409 }
6410
6412 ONIXS_B3_UMDF_MD_NODISCARD
6413 bool enteringFirm(FirmOptional& value) const
6414 noexcept
6415 {
6416 constexpr BlockLength offset = 32;
6417
6418 return ordinary(value, offset, NullFirmOptional());
6419 }
6420
6424 ONIXS_B3_UMDF_MD_NODISCARD
6425 bool mDInsertTimestamp(UTCTimestampNanos& value) const
6426 noexcept
6427 {
6428 constexpr BlockLength offset = 36;
6429
6430 return ordinary(value, offset, NullUTCTimestampNanos());
6431 }
6432
6440 ONIXS_B3_UMDF_MD_NODISCARD
6441 OrderID secondaryOrderId() const
6442 noexcept
6443 {
6444 constexpr BlockLength offset = 44;
6445
6446 return ordinary<OrderID>(offset);
6447 }
6448
6451 ONIXS_B3_UMDF_MD_NODISCARD
6452 bool rptSeq(RptSeq& value) const
6453 noexcept
6454 {
6455 constexpr BlockLength offset = 52;
6456
6457 return ordinary(value, offset, NullRptSeq());
6458 }
6459
6461 ONIXS_B3_UMDF_MD_NODISCARD
6462 bool transactTime(UTCTimestampNanos& value) const
6463 noexcept
6464 {
6465 constexpr BlockLength offset = 56;
6466
6467 return ordinary(value, offset, NullUTCTimestampNanos());
6468 }
6469
6475 ONIXS_B3_UMDF_MD_NODISCARD
6476 bool mDEntryPrevSize(QuantityOptional& value) const
6477 noexcept
6478 {
6479 constexpr BlockLength offset = 64;
6480 constexpr SchemaVersion since = 16;
6481
6482 return ordinary(value, offset, NullQuantityOptional(), since);
6483 }
6484
6486 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6487 constexpr
6488 static BlockLength minimalBlockLength(SchemaVersion version)
6489 noexcept
6490 {
6491 return
6492 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6493 (version >= 16)
6494 ? 72
6495 : 64;
6496 }
6497
6499 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6500 constexpr
6501 static
6502 BlockLength
6503 blockLength(
6504 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6505 noexcept
6506 {
6507 return
6508 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6509 minimalBlockLength(version);
6510 }
6511
6513 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6514 ONIXS_B3_UMDF_MD_NODISCARD
6515 constexpr
6516 static
6517 MessageSize
6518 getMinimalVariableFieldsSize(
6519 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6520 {
6521 return
6522 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6523 0;
6524 }
6525
6527 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6528 ONIXS_B3_UMDF_MD_NODISCARD
6529 constexpr
6530 static StrRef className()
6531 noexcept
6532 {
6533 return constructStrRef("Order_MBO_50");
6534 }
6535
6537 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6538 ONIXS_B3_UMDF_MD_NODISCARD
6539 constexpr
6540 static StrRef fixType()
6541 noexcept
6542 {
6543 return constructStrRef("Order_MBO_50");
6544 }
6545
6547 ONIXS_B3_UMDF_MD_NODISCARD
6548 std::string toString() const;
6549
6550private:
6551 void checkLength(
6552 EncodedLength length, SchemaVersion version) const
6553 {
6554 const EncodedLength minimalRequiredLength =
6555 minimalBlockLength(version) +
6556 MessageHeader::Size +
6557 getMinimalVariableFieldsSize(version);
6558
6559 checkBinaryLength(
6560 *this, length, minimalRequiredLength);
6561 }
6562
6563 void checkCompatibility() const
6564 {
6565 assert(TemplateId == templateId());
6566
6567 checkSchema<Schema>(schemaId(), version());
6568 checkLength(bufferSize(), version());
6569 }
6570};
6571
6573ONIXS_B3_UMDF_MD_LTWT_STRUCT
6574DeleteOrder_MBO_51
6575: SbeMessage
6576{
6578 typedef SchemaTraits Schema;
6579
6581 enum { TemplateId = 51 };
6582
6584 DeleteOrder_MBO_51() = default;
6585
6587 DeleteOrder_MBO_51(
6588 void* data,
6589 EncodedLength length,
6590 NoInit)
6591 : SbeMessage(data, length)
6592 {
6593 checkCompatibility();
6594 }
6595
6597 explicit
6598 DeleteOrder_MBO_51(
6599 const SbeMessage& message)
6600 : SbeMessage(message)
6601 {
6602 assert(message.valid());
6603
6604 checkCompatibility();
6605 }
6606
6609 DeleteOrder_MBO_51(
6610 void* data,
6611 EncodedLength length,
6612 NoInit,
6613 NoCheck)
6614 noexcept
6615 : SbeMessage(data, length, NoCheck())
6616 {
6617 assert(schemaId() == Schema::Id);
6618 assert(version() >= Schema::MinimalVersion);
6619 assert(TemplateId == templateId());
6620 }
6621
6623 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6624 constexpr
6630
6633 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6634 constexpr
6635 static ApplVerID::Enum applVerId()
6636 noexcept
6637 {
6638 return ApplVerID::FIX50SP2;
6639 }
6640
6643 ONIXS_B3_UMDF_MD_NODISCARD
6644 SecurityID securityId() const
6645 noexcept
6646 {
6647 constexpr BlockLength offset = 0;
6648
6649 return ordinary<SecurityID>(offset);
6650 }
6651
6653 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6654 constexpr
6660
6662 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6663 ONIXS_B3_UMDF_MD_NODISCARD
6664 constexpr
6665 static StrRef securityExchange()
6666 noexcept
6667 {
6668 return constructStrRef("BVMF");
6669 }
6670
6673 ONIXS_B3_UMDF_MD_NODISCARD
6674 MatchEventIndicator matchEventIndicator() const
6675 noexcept
6676 {
6677 constexpr BlockLength offset = 8;
6678
6679 return ordinary<MatchEventIndicator>(offset);
6680 }
6681
6683 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6684 constexpr
6685 static UpdateAction::Enum mDUpdateAction()
6686 noexcept
6687 {
6688 return UpdateAction::DELETE;
6689 }
6690
6692 ONIXS_B3_UMDF_MD_NODISCARD
6693 EntryType::Enum mDEntryType() const
6694 noexcept
6695 {
6696 constexpr BlockLength offset = 10;
6697
6698 return enumeration<EntryType>(offset);
6699 }
6700
6702 ONIXS_B3_UMDF_MD_NODISCARD
6703 Quantity mDEntrySize() const
6704 noexcept
6705 {
6706 constexpr BlockLength offset = 16;
6707
6708 return ordinary<Quantity>(offset);
6709 }
6710
6716 ONIXS_B3_UMDF_MD_NODISCARD
6717 OrderID secondaryOrderId() const
6718 noexcept
6719 {
6720 constexpr BlockLength offset = 24;
6721
6722 return ordinary<OrderID>(offset);
6723 }
6724
6726 ONIXS_B3_UMDF_MD_NODISCARD
6727 bool transactTime(UTCTimestampNanos& value) const
6728 noexcept
6729 {
6730 constexpr BlockLength offset = 32;
6731
6732 return ordinary(value, offset, NullUTCTimestampNanos());
6733 }
6734
6737 ONIXS_B3_UMDF_MD_NODISCARD
6738 bool rptSeq(RptSeq& value) const
6739 noexcept
6740 {
6741 constexpr BlockLength offset = 40;
6742
6743 return ordinary(value, offset, NullRptSeq());
6744 }
6745
6747 ONIXS_B3_UMDF_MD_NODISCARD
6748 bool mDEntryPx(PriceOptional& value) const
6749 noexcept
6750 {
6751 constexpr BlockLength offset = 44;
6752
6753 return decimal(value, offset, NullPriceOptional());
6754 }
6755
6757 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6758 constexpr
6759 static
6760 BlockLength
6761 minimalBlockLength(
6762 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6763 noexcept
6764 {
6765 return
6766 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6767 52;
6768 }
6769
6771 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6772 constexpr
6773 static
6774 BlockLength
6775 blockLength(
6776 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6777 noexcept
6778 {
6779 return
6780 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6781 minimalBlockLength(version);
6782 }
6783
6785 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6786 ONIXS_B3_UMDF_MD_NODISCARD
6787 constexpr
6788 static
6789 MessageSize
6790 getMinimalVariableFieldsSize(
6791 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6792 {
6793 return
6794 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6795 0;
6796 }
6797
6799 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6800 ONIXS_B3_UMDF_MD_NODISCARD
6801 constexpr
6802 static StrRef className()
6803 noexcept
6804 {
6805 return constructStrRef("DeleteOrder_MBO_51");
6806 }
6807
6809 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6810 ONIXS_B3_UMDF_MD_NODISCARD
6811 constexpr
6812 static StrRef fixType()
6813 noexcept
6814 {
6815 return constructStrRef("DeleteOrder_MBO_51");
6816 }
6817
6819 ONIXS_B3_UMDF_MD_NODISCARD
6820 std::string toString() const;
6821
6822private:
6823 void checkLength(
6824 EncodedLength length, SchemaVersion version) const
6825 {
6826 const EncodedLength minimalRequiredLength =
6827 minimalBlockLength(version) +
6828 MessageHeader::Size +
6829 getMinimalVariableFieldsSize(version);
6830
6831 checkBinaryLength(
6832 *this, length, minimalRequiredLength);
6833 }
6834
6835 void checkCompatibility() const
6836 {
6837 assert(TemplateId == templateId());
6838
6839 checkSchema<Schema>(schemaId(), version());
6840 checkLength(bufferSize(), version());
6841 }
6842};
6843
6845ONIXS_B3_UMDF_MD_LTWT_STRUCT
6846MassDeleteOrders_MBO_52
6847: SbeMessage
6848{
6850 typedef SchemaTraits Schema;
6851
6853 enum { TemplateId = 52 };
6854
6856 MassDeleteOrders_MBO_52() = default;
6857
6859 MassDeleteOrders_MBO_52(
6860 void* data,
6861 EncodedLength length,
6862 NoInit)
6863 : SbeMessage(data, length)
6864 {
6865 checkCompatibility();
6866 }
6867
6869 explicit
6870 MassDeleteOrders_MBO_52(
6871 const SbeMessage& message)
6872 : SbeMessage(message)
6873 {
6874 assert(message.valid());
6875
6876 checkCompatibility();
6877 }
6878
6881 MassDeleteOrders_MBO_52(
6882 void* data,
6883 EncodedLength length,
6884 NoInit,
6885 NoCheck)
6886 noexcept
6887 : SbeMessage(data, length, NoCheck())
6888 {
6889 assert(schemaId() == Schema::Id);
6890 assert(version() >= Schema::MinimalVersion);
6891 assert(TemplateId == templateId());
6892 }
6893
6895 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6896 constexpr
6902
6905 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6906 constexpr
6907 static ApplVerID::Enum applVerId()
6908 noexcept
6909 {
6910 return ApplVerID::FIX50SP2;
6911 }
6912
6915 ONIXS_B3_UMDF_MD_NODISCARD
6916 SecurityID securityId() const
6917 noexcept
6918 {
6919 constexpr BlockLength offset = 0;
6920
6921 return ordinary<SecurityID>(offset);
6922 }
6923
6925 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6926 constexpr
6932
6934 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6935 ONIXS_B3_UMDF_MD_NODISCARD
6936 constexpr
6937 static StrRef securityExchange()
6938 noexcept
6939 {
6940 return constructStrRef("BVMF");
6941 }
6942
6945 ONIXS_B3_UMDF_MD_NODISCARD
6946 MatchEventIndicator matchEventIndicator() const
6947 noexcept
6948 {
6949 constexpr BlockLength offset = 8;
6950
6951 return ordinary<MatchEventIndicator>(offset);
6952 }
6953
6955 ONIXS_B3_UMDF_MD_NODISCARD
6956 UpdateAction::Enum mDUpdateAction() const
6957 noexcept
6958 {
6959 constexpr BlockLength offset = 9;
6960
6961 return enumeration<UpdateAction>(offset);
6962 }
6963
6965 ONIXS_B3_UMDF_MD_NODISCARD
6966 EntryType::Enum mDEntryType() const
6967 noexcept
6968 {
6969 constexpr BlockLength offset = 10;
6970
6971 return enumeration<EntryType>(offset);
6972 }
6973
6975 ONIXS_B3_UMDF_MD_NODISCARD
6976 bool transactTime(UTCTimestampNanos& value) const
6977 noexcept
6978 {
6979 constexpr BlockLength offset = 16;
6980
6981 return ordinary(value, offset, NullUTCTimestampNanos());
6982 }
6983
6986 ONIXS_B3_UMDF_MD_NODISCARD
6987 bool rptSeq(RptSeq& value) const
6988 noexcept
6989 {
6990 constexpr BlockLength offset = 24;
6991
6992 return ordinary(value, offset, NullRptSeq());
6993 }
6994
6996 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6997 constexpr
6998 static
6999 BlockLength
7000 minimalBlockLength(
7001 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7002 noexcept
7003 {
7004 return
7005 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7006 28;
7007 }
7008
7010 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7011 constexpr
7012 static
7013 BlockLength
7014 blockLength(
7015 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7016 noexcept
7017 {
7018 return
7019 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7020 minimalBlockLength(version);
7021 }
7022
7024 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7025 ONIXS_B3_UMDF_MD_NODISCARD
7026 constexpr
7027 static
7028 MessageSize
7029 getMinimalVariableFieldsSize(
7030 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7031 {
7032 return
7033 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7034 0;
7035 }
7036
7038 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7039 ONIXS_B3_UMDF_MD_NODISCARD
7040 constexpr
7041 static StrRef className()
7042 noexcept
7043 {
7044 return constructStrRef("MassDeleteOrders_MBO_52");
7045 }
7046
7048 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7049 ONIXS_B3_UMDF_MD_NODISCARD
7050 constexpr
7051 static StrRef fixType()
7052 noexcept
7053 {
7054 return constructStrRef(
7055 "MassDeleteOrders_MBO_52");
7056 }
7057
7059 ONIXS_B3_UMDF_MD_NODISCARD
7060 std::string toString() const;
7061
7062private:
7063 void checkLength(
7064 EncodedLength length, SchemaVersion version) const
7065 {
7066 const EncodedLength minimalRequiredLength =
7067 minimalBlockLength(version) +
7068 MessageHeader::Size +
7069 getMinimalVariableFieldsSize(version);
7070
7071 checkBinaryLength(
7072 *this, length, minimalRequiredLength);
7073 }
7074
7075 void checkCompatibility() const
7076 {
7077 assert(TemplateId == templateId());
7078
7079 checkSchema<Schema>(schemaId(), version());
7080 checkLength(bufferSize(), version());
7081 }
7082};
7083
7085ONIXS_B3_UMDF_MD_LTWT_STRUCT
7086Trade_53
7087: SbeMessage
7088{
7090 typedef SchemaTraits Schema;
7091
7093 enum { TemplateId = 53 };
7094
7096 Trade_53() = default;
7097
7099 Trade_53(
7100 void* data,
7101 EncodedLength length,
7102 NoInit)
7103 : SbeMessage(data, length)
7104 {
7105 checkCompatibility();
7106 }
7107
7109 explicit
7110 Trade_53(
7111 const SbeMessage& message)
7112 : SbeMessage(message)
7113 {
7114 assert(message.valid());
7115
7116 checkCompatibility();
7117 }
7118
7121 Trade_53(
7122 void* data,
7123 EncodedLength length,
7124 NoInit,
7125 NoCheck)
7126 noexcept
7127 : SbeMessage(data, length, NoCheck())
7128 {
7129 assert(schemaId() == Schema::Id);
7130 assert(version() >= Schema::MinimalVersion);
7131 assert(TemplateId == templateId());
7132 }
7133
7135 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7136 constexpr
7142
7145 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7146 constexpr
7147 static ApplVerID::Enum applVerId()
7148 noexcept
7149 {
7150 return ApplVerID::FIX50SP2;
7151 }
7152
7155 ONIXS_B3_UMDF_MD_NODISCARD
7156 SecurityID securityId() const
7157 noexcept
7158 {
7159 constexpr BlockLength offset = 0;
7160
7161 return ordinary<SecurityID>(offset);
7162 }
7163
7165 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7166 constexpr
7172
7174 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7175 ONIXS_B3_UMDF_MD_NODISCARD
7176 constexpr
7177 static StrRef securityExchange()
7178 noexcept
7179 {
7180 return constructStrRef("BVMF");
7181 }
7182
7185 ONIXS_B3_UMDF_MD_NODISCARD
7186 MatchEventIndicator matchEventIndicator() const
7187 noexcept
7188 {
7189 constexpr BlockLength offset = 8;
7190
7191 return ordinary<MatchEventIndicator>(offset);
7192 }
7193
7195 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7196 constexpr
7197 static UpdateAction::Enum mDUpdateAction()
7198 noexcept
7199 {
7200 return UpdateAction::NEW;
7201 }
7202
7204 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7205 constexpr
7206 static EntryType::Enum mDEntryType()
7207 noexcept
7208 {
7209 return EntryType::TRADE;
7210 }
7211
7213 ONIXS_B3_UMDF_MD_NODISCARD
7214 TradingSessionID::Enum tradingSessionId() const
7215 noexcept
7216 {
7217 constexpr BlockLength offset = 9;
7218
7219 return enumeration<TradingSessionID>(offset);
7220 }
7221
7223 ONIXS_B3_UMDF_MD_NODISCARD
7224 TradeCondition tradeCondition() const
7225 noexcept
7226 {
7227 constexpr BlockLength offset = 10;
7228
7229 return ordinary<TradeCondition>(offset);
7230 }
7231
7233 ONIXS_B3_UMDF_MD_NODISCARD
7234 Price mDEntryPx() const
7235 noexcept
7236 {
7237 constexpr BlockLength offset = 12;
7238
7239 return decimal<Price>(offset);
7240 }
7241
7243 ONIXS_B3_UMDF_MD_NODISCARD
7244 Quantity mDEntrySize() const
7245 noexcept
7246 {
7247 constexpr BlockLength offset = 20;
7248
7249 return ordinary<Quantity>(offset);
7250 }
7251
7255 ONIXS_B3_UMDF_MD_NODISCARD
7256 TradeID tradeId() const
7257 noexcept
7258 {
7259 constexpr BlockLength offset = 28;
7260
7261 return ordinary<TradeID>(offset);
7262 }
7263
7265 ONIXS_B3_UMDF_MD_NODISCARD
7266 bool mDEntryBuyer(FirmOptional& value) const
7267 noexcept
7268 {
7269 constexpr BlockLength offset = 32;
7270
7271 return ordinary(value, offset, NullFirmOptional());
7272 }
7273
7275 ONIXS_B3_UMDF_MD_NODISCARD
7276 bool mDEntrySeller(FirmOptional& value) const
7277 noexcept
7278 {
7279 constexpr BlockLength offset = 36;
7280
7281 return ordinary(value, offset, NullFirmOptional());
7282 }
7283
7286 ONIXS_B3_UMDF_MD_NODISCARD
7287 Timestamp tradeDate() const
7288 noexcept
7289 {
7290 constexpr BlockLength offset = 40;
7291
7292 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
7293 }
7294
7296 ONIXS_B3_UMDF_MD_NODISCARD
7297 bool trdSubType(TrdSubType::Enum& value) const
7298 noexcept
7299 {
7300 constexpr BlockLength offset = 42;
7301
7302 return enumeration<TrdSubType>(value, offset, NullUInt8NULL());
7303 }
7304
7307 ONIXS_B3_UMDF_MD_NODISCARD
7308 bool transactTime(UTCTimestampNanos& value) const
7309 noexcept
7310 {
7311 constexpr BlockLength offset = 44;
7312
7313 return ordinary(value, offset, NullUTCTimestampNanos());
7314 }
7315
7318 ONIXS_B3_UMDF_MD_NODISCARD
7319 bool rptSeq(RptSeq& value) const
7320 noexcept
7321 {
7322 constexpr BlockLength offset = 52;
7323
7324 return ordinary(value, offset, NullRptSeq());
7325 }
7326
7328 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7329 constexpr
7330 static
7331 BlockLength
7332 minimalBlockLength(
7333 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7334 noexcept
7335 {
7336 return
7337 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7338 56;
7339 }
7340
7342 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7343 constexpr
7344 static
7345 BlockLength
7346 blockLength(
7347 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7348 noexcept
7349 {
7350 return
7351 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7352 minimalBlockLength(version);
7353 }
7354
7356 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7357 ONIXS_B3_UMDF_MD_NODISCARD
7358 constexpr
7359 static
7360 MessageSize
7361 getMinimalVariableFieldsSize(
7362 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7363 {
7364 return
7365 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7366 0;
7367 }
7368
7370 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7371 ONIXS_B3_UMDF_MD_NODISCARD
7372 constexpr
7373 static StrRef className()
7374 noexcept
7375 {
7376 return constructStrRef("Trade_53");
7377 }
7378
7380 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7381 ONIXS_B3_UMDF_MD_NODISCARD
7382 constexpr
7383 static StrRef fixType()
7384 noexcept
7385 {
7386 return constructStrRef("Trade_53");
7387 }
7388
7390 ONIXS_B3_UMDF_MD_NODISCARD
7391 std::string toString() const;
7392
7393private:
7394 void checkLength(
7395 EncodedLength length, SchemaVersion version) const
7396 {
7397 const EncodedLength minimalRequiredLength =
7398 minimalBlockLength(version) +
7399 MessageHeader::Size +
7400 getMinimalVariableFieldsSize(version);
7401
7402 checkBinaryLength(
7403 *this, length, minimalRequiredLength);
7404 }
7405
7406 void checkCompatibility() const
7407 {
7408 assert(TemplateId == templateId());
7409
7410 checkSchema<Schema>(schemaId(), version());
7411 checkLength(bufferSize(), version());
7412 }
7413};
7414
7416ONIXS_B3_UMDF_MD_LTWT_STRUCT
7417ForwardTrade_54
7418: SbeMessage
7419{
7421 typedef SchemaTraits Schema;
7422
7424 enum { TemplateId = 54 };
7425
7427 ForwardTrade_54() = default;
7428
7430 ForwardTrade_54(
7431 void* data,
7432 EncodedLength length,
7433 NoInit)
7434 : SbeMessage(data, length)
7435 {
7436 checkCompatibility();
7437 }
7438
7440 explicit
7441 ForwardTrade_54(
7442 const SbeMessage& message)
7443 : SbeMessage(message)
7444 {
7445 assert(message.valid());
7446
7447 checkCompatibility();
7448 }
7449
7452 ForwardTrade_54(
7453 void* data,
7454 EncodedLength length,
7455 NoInit,
7456 NoCheck)
7457 noexcept
7458 : SbeMessage(data, length, NoCheck())
7459 {
7460 assert(schemaId() == Schema::Id);
7461 assert(version() >= Schema::MinimalVersion);
7462 assert(TemplateId == templateId());
7463 }
7464
7466 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7467 constexpr
7473
7476 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7477 constexpr
7478 static ApplVerID::Enum applVerId()
7479 noexcept
7480 {
7481 return ApplVerID::FIX50SP2;
7482 }
7483
7486 ONIXS_B3_UMDF_MD_NODISCARD
7487 SecurityID securityId() const
7488 noexcept
7489 {
7490 constexpr BlockLength offset = 0;
7491
7492 return ordinary<SecurityID>(offset);
7493 }
7494
7496 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7497 constexpr
7503
7505 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7506 ONIXS_B3_UMDF_MD_NODISCARD
7507 constexpr
7508 static StrRef securityExchange()
7509 noexcept
7510 {
7511 return constructStrRef("BVMF");
7512 }
7513
7516 ONIXS_B3_UMDF_MD_NODISCARD
7517 MatchEventIndicator matchEventIndicator() const
7518 noexcept
7519 {
7520 constexpr BlockLength offset = 8;
7521
7522 return ordinary<MatchEventIndicator>(offset);
7523 }
7524
7526 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7527 constexpr
7528 static UpdateAction::Enum mDUpdateAction()
7529 noexcept
7530 {
7531 return UpdateAction::NEW;
7532 }
7533
7535 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7536 constexpr
7537 static EntryType::Enum mDEntryType()
7538 noexcept
7539 {
7540 return EntryType::TRADE;
7541 }
7542
7544 ONIXS_B3_UMDF_MD_NODISCARD
7545 TradingSessionID::Enum tradingSessionId() const
7546 noexcept
7547 {
7548 constexpr BlockLength offset = 9;
7549
7550 return enumeration<TradingSessionID>(offset);
7551 }
7552
7554 ONIXS_B3_UMDF_MD_NODISCARD
7555 TradeCondition tradeCondition() const
7556 noexcept
7557 {
7558 constexpr BlockLength offset = 10;
7559
7560 return ordinary<TradeCondition>(offset);
7561 }
7562
7564 ONIXS_B3_UMDF_MD_NODISCARD
7565 Price mDEntryPx() const
7566 noexcept
7567 {
7568 constexpr BlockLength offset = 12;
7569
7570 return decimal<Price>(offset);
7571 }
7572
7574 ONIXS_B3_UMDF_MD_NODISCARD
7575 Quantity mDEntrySize() const
7576 noexcept
7577 {
7578 constexpr BlockLength offset = 20;
7579
7580 return ordinary<Quantity>(offset);
7581 }
7582
7586 ONIXS_B3_UMDF_MD_NODISCARD
7587 TradeID tradeId() const
7588 noexcept
7589 {
7590 constexpr BlockLength offset = 28;
7591
7592 return ordinary<TradeID>(offset);
7593 }
7594
7596 ONIXS_B3_UMDF_MD_NODISCARD
7597 bool mDEntryBuyer(FirmOptional& value) const
7598 noexcept
7599 {
7600 constexpr BlockLength offset = 32;
7601
7602 return ordinary(value, offset, NullFirmOptional());
7603 }
7604
7606 ONIXS_B3_UMDF_MD_NODISCARD
7607 bool mDEntrySeller(FirmOptional& value) const
7608 noexcept
7609 {
7610 constexpr BlockLength offset = 36;
7611
7612 return ordinary(value, offset, NullFirmOptional());
7613 }
7614
7617 ONIXS_B3_UMDF_MD_NODISCARD
7618 Timestamp tradeDate() const
7619 noexcept
7620 {
7621 constexpr BlockLength offset = 40;
7622
7623 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
7624 }
7625
7628 ONIXS_B3_UMDF_MD_NODISCARD
7629 bool transactTime(UTCTimestampNanos& value) const
7630 noexcept
7631 {
7632 constexpr BlockLength offset = 42;
7633
7634 return ordinary(value, offset, NullUTCTimestampNanos());
7635 }
7636
7639 ONIXS_B3_UMDF_MD_NODISCARD
7640 bool rptSeq(RptSeq& value) const
7641 noexcept
7642 {
7643 constexpr BlockLength offset = 50;
7644
7645 return ordinary(value, offset, NullRptSeq());
7646 }
7647
7651 ONIXS_B3_UMDF_MD_NODISCARD
7652 bool sellerDays(UInt16NULL& value) const
7653 noexcept
7654 {
7655 constexpr BlockLength offset = 54;
7656
7657 return ordinary(value, offset, NullUInt16NULL());
7658 }
7659
7663 ONIXS_B3_UMDF_MD_NODISCARD
7664 bool mDEntryInterestRate(Percentage& value) const
7665 noexcept
7666 {
7667 constexpr BlockLength offset = 56;
7668
7669 return decimal(value, offset, NullPercentage());
7670 }
7671
7673 ONIXS_B3_UMDF_MD_NODISCARD
7674 bool trdSubType(TrdSubType::Enum& value) const
7675 noexcept
7676 {
7677 constexpr BlockLength offset = 64;
7678
7679 return enumeration<TrdSubType>(value, offset, NullUInt8NULL());
7680 }
7681
7683 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7684 constexpr
7685 static
7686 BlockLength
7687 minimalBlockLength(
7688 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7689 noexcept
7690 {
7691 return
7692 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7693 68;
7694 }
7695
7697 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7698 constexpr
7699 static
7700 BlockLength
7701 blockLength(
7702 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7703 noexcept
7704 {
7705 return
7706 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7707 68;
7708 }
7709
7711 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7712 ONIXS_B3_UMDF_MD_NODISCARD
7713 constexpr
7714 static
7715 MessageSize
7716 getMinimalVariableFieldsSize(
7717 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7718 {
7719 return
7720 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7721 0;
7722 }
7723
7725 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7726 ONIXS_B3_UMDF_MD_NODISCARD
7727 constexpr
7728 static StrRef className()
7729 noexcept
7730 {
7731 return constructStrRef("ForwardTrade_54");
7732 }
7733
7735 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7736 ONIXS_B3_UMDF_MD_NODISCARD
7737 constexpr
7738 static StrRef fixType()
7739 noexcept
7740 {
7741 return constructStrRef("ForwardTrade_54");
7742 }
7743
7745 ONIXS_B3_UMDF_MD_NODISCARD
7746 std::string toString() const;
7747
7748private:
7749 void checkLength(
7750 EncodedLength length, SchemaVersion version) const
7751 {
7752 const EncodedLength minimalRequiredLength =
7753 minimalBlockLength(version) +
7754 MessageHeader::Size +
7755 getMinimalVariableFieldsSize(version);
7756
7757 checkBinaryLength(
7758 *this, length, minimalRequiredLength);
7759 }
7760
7761 void checkCompatibility() const
7762 {
7763 assert(TemplateId == templateId());
7764
7765 checkSchema<Schema>(schemaId(), version());
7766 checkLength(bufferSize(), version());
7767 }
7768};
7769
7771ONIXS_B3_UMDF_MD_LTWT_STRUCT
7772ExecutionSummary_55
7773: SbeMessage
7774{
7776 typedef SchemaTraits Schema;
7777
7779 enum { TemplateId = 55 };
7780
7782 ExecutionSummary_55() = default;
7783
7785 ExecutionSummary_55(
7786 void* data,
7787 EncodedLength length,
7788 NoInit)
7789 : SbeMessage(data, length)
7790 {
7791 checkCompatibility();
7792 }
7793
7795 explicit
7796 ExecutionSummary_55(
7797 const SbeMessage& message)
7798 : SbeMessage(message)
7799 {
7800 assert(message.valid());
7801
7802 checkCompatibility();
7803 }
7804
7807 ExecutionSummary_55(
7808 void* data,
7809 EncodedLength length,
7810 NoInit,
7811 NoCheck)
7812 noexcept
7813 : SbeMessage(data, length, NoCheck())
7814 {
7815 assert(schemaId() == Schema::Id);
7816 assert(version() >= Schema::MinimalVersion);
7817 assert(TemplateId == templateId());
7818 }
7819
7821 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7822 constexpr
7828
7831 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7832 constexpr
7833 static ApplVerID::Enum applVerId()
7834 noexcept
7835 {
7836 return ApplVerID::FIX50SP2;
7837 }
7838
7841 ONIXS_B3_UMDF_MD_NODISCARD
7842 SecurityID securityId() const
7843 noexcept
7844 {
7845 constexpr BlockLength offset = 0;
7846
7847 return ordinary<SecurityID>(offset);
7848 }
7849
7851 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7852 constexpr
7858
7860 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7861 ONIXS_B3_UMDF_MD_NODISCARD
7862 constexpr
7863 static StrRef securityExchange()
7864 noexcept
7865 {
7866 return constructStrRef("BVMF");
7867 }
7868
7870 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7871 constexpr
7872 static UpdateAction::Enum mDUpdateAction()
7873 noexcept
7874 {
7875 return UpdateAction::NEW;
7876 }
7877
7879 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7880 constexpr
7881 static EntryType::Enum mDEntryType()
7882 noexcept
7883 {
7884 return EntryType::EXECUTION_SUMMARY;
7885 }
7886
7888 ONIXS_B3_UMDF_MD_NODISCARD
7889 AggressorSide::Enum aggressorSide() const
7890 noexcept
7891 {
7892 constexpr BlockLength offset = 10;
7893
7894 return enumeration<AggressorSide>(offset);
7895 }
7896
7898 ONIXS_B3_UMDF_MD_NODISCARD
7899 Price lastPx() const
7900 noexcept
7901 {
7902 constexpr BlockLength offset = 12;
7903
7904 return decimal<Price>(offset);
7905 }
7906
7908 ONIXS_B3_UMDF_MD_NODISCARD
7909 Quantity fillQty() const
7910 noexcept
7911 {
7912 constexpr BlockLength offset = 20;
7913
7914 return ordinary<Quantity>(offset);
7915 }
7916
7919 ONIXS_B3_UMDF_MD_NODISCARD
7920 bool tradedHiddenQty(QuantityOptional& value) const
7921 noexcept
7922 {
7923 constexpr BlockLength offset = 28;
7924
7925 return ordinary(value, offset, NullQuantityOptional());
7926 }
7927
7930 ONIXS_B3_UMDF_MD_NODISCARD
7931 bool cxlQty(QuantityOptional& value) const
7932 noexcept
7933 {
7934 constexpr BlockLength offset = 36;
7935
7936 return ordinary(value, offset, NullQuantityOptional());
7937 }
7938
7940 ONIXS_B3_UMDF_MD_NODISCARD
7941 bool aggressorTime(UTCTimestampNanos& value) const
7942 noexcept
7943 {
7944 constexpr BlockLength offset = 44;
7945
7946 return ordinary(value, offset, NullUTCTimestampNanos());
7947 }
7948
7951 ONIXS_B3_UMDF_MD_NODISCARD
7952 bool rptSeq(RptSeq& value) const
7953 noexcept
7954 {
7955 constexpr BlockLength offset = 52;
7956
7957 return ordinary(value, offset, NullRptSeq());
7958 }
7959
7962 ONIXS_B3_UMDF_MD_NODISCARD
7963 bool transactTime(UTCTimestampNanos& value) const
7964 noexcept
7965 {
7966 constexpr BlockLength offset = 56;
7967
7968 return ordinary(value, offset, NullUTCTimestampNanos());
7969 }
7970
7972 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7973 constexpr
7974 static
7975 BlockLength
7976 minimalBlockLength(
7977 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7978 noexcept
7979 {
7980 return
7981 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7982 64;
7983 }
7984
7986 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7987 constexpr
7988 static
7989 BlockLength
7990 blockLength(
7991 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7992 noexcept
7993 {
7994 return
7995 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7996 minimalBlockLength(version);
7997 }
7998
8000 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8001 ONIXS_B3_UMDF_MD_NODISCARD
8002 constexpr
8003 static
8004 MessageSize
8005 getMinimalVariableFieldsSize(
8006 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8007 {
8008 return
8009 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8010 0;
8011 }
8012
8014 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8015 ONIXS_B3_UMDF_MD_NODISCARD
8016 constexpr
8017 static StrRef className()
8018 noexcept
8019 {
8020 return constructStrRef("ExecutionSummary_55");
8021 }
8022
8024 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8025 ONIXS_B3_UMDF_MD_NODISCARD
8026 constexpr
8027 static StrRef fixType()
8028 noexcept
8029 {
8030 return constructStrRef("ExecutionSummary_55");
8031 }
8032
8034 ONIXS_B3_UMDF_MD_NODISCARD
8035 std::string toString() const;
8036
8037private:
8038 void checkLength(
8039 EncodedLength length, SchemaVersion version) const
8040 {
8041 const EncodedLength minimalRequiredLength =
8042 minimalBlockLength(version) +
8043 MessageHeader::Size +
8044 getMinimalVariableFieldsSize(version);
8045
8046 checkBinaryLength(
8047 *this, length, minimalRequiredLength);
8048 }
8049
8050 void checkCompatibility() const
8051 {
8052 assert(TemplateId == templateId());
8053
8054 checkSchema<Schema>(schemaId(), version());
8055 checkLength(bufferSize(), version());
8056 }
8057};
8058
8060ONIXS_B3_UMDF_MD_LTWT_STRUCT
8061ExecutionStatistics_56
8062: SbeMessage
8063{
8065 typedef SchemaTraits Schema;
8066
8068 enum { TemplateId = 56 };
8069
8071 ExecutionStatistics_56() = default;
8072
8074 ExecutionStatistics_56(
8075 void* data,
8076 EncodedLength length,
8077 NoInit)
8078 : SbeMessage(data, length)
8079 {
8080 checkCompatibility();
8081 }
8082
8084 explicit
8085 ExecutionStatistics_56(
8086 const SbeMessage& message)
8087 : SbeMessage(message)
8088 {
8089 assert(message.valid());
8090
8091 checkCompatibility();
8092 }
8093
8096 ExecutionStatistics_56(
8097 void* data,
8098 EncodedLength length,
8099 NoInit,
8100 NoCheck)
8101 noexcept
8102 : SbeMessage(data, length, NoCheck())
8103 {
8104 assert(schemaId() == Schema::Id);
8105 assert(version() >= Schema::MinimalVersion);
8106 assert(TemplateId == templateId());
8107 }
8108
8110 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8111 constexpr
8117
8120 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8121 constexpr
8122 static ApplVerID::Enum applVerId()
8123 noexcept
8124 {
8125 return ApplVerID::FIX50SP2;
8126 }
8127
8130 ONIXS_B3_UMDF_MD_NODISCARD
8131 SecurityID securityId() const
8132 noexcept
8133 {
8134 constexpr BlockLength offset = 0;
8135
8136 return ordinary<SecurityID>(offset);
8137 }
8138
8140 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8141 constexpr
8147
8149 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8150 ONIXS_B3_UMDF_MD_NODISCARD
8151 constexpr
8152 static StrRef securityExchange()
8153 noexcept
8154 {
8155 return constructStrRef("BVMF");
8156 }
8157
8160 ONIXS_B3_UMDF_MD_NODISCARD
8161 MatchEventIndicator matchEventIndicator() const
8162 noexcept
8163 {
8164 constexpr BlockLength offset = 8;
8165
8166 return ordinary<MatchEventIndicator>(offset);
8167 }
8168
8170 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8171 constexpr
8172 static UpdateAction::Enum mDUpdateAction()
8173 noexcept
8174 {
8175 return UpdateAction::NEW;
8176 }
8177
8179 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8180 constexpr
8186
8188 ONIXS_B3_UMDF_MD_NODISCARD
8189 TradingSessionID::Enum tradingSessionId() const
8190 noexcept
8191 {
8192 constexpr BlockLength offset = 9;
8193
8194 return enumeration<TradingSessionID>(offset);
8195 }
8196
8199 ONIXS_B3_UMDF_MD_NODISCARD
8200 Timestamp tradeDate() const
8201 noexcept
8202 {
8203 constexpr BlockLength offset = 10;
8204
8205 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
8206 }
8207
8209 ONIXS_B3_UMDF_MD_NODISCARD
8210 QuantityVolume tradeVolume() const
8211 noexcept
8212 {
8213 constexpr BlockLength offset = 12;
8214
8215 return ordinary<QuantityVolume>(offset);
8216 }
8217
8219 ONIXS_B3_UMDF_MD_NODISCARD
8220 bool vwapPx(PriceOptional& value) const
8221 noexcept
8222 {
8223 constexpr BlockLength offset = 20;
8224
8225 return decimal(value, offset, NullPriceOptional());
8226 }
8227
8230 ONIXS_B3_UMDF_MD_NODISCARD
8231 bool
8232 netChgPrevDay(
8233 PriceOffset8Optional& value) const
8234 noexcept
8235 {
8236 constexpr BlockLength offset = 28;
8237
8238 return decimal(value, offset, NullPriceOffset8Optional());
8239 }
8240
8242 ONIXS_B3_UMDF_MD_NODISCARD
8243 NumberOfTrades numberOfTrades() const
8244 noexcept
8245 {
8246 constexpr BlockLength offset = 36;
8247
8248 return ordinary<NumberOfTrades>(offset);
8249 }
8250
8252 ONIXS_B3_UMDF_MD_NODISCARD
8253 bool mDEntryTimestamp(UTCTimestampNanos& value) const
8254 noexcept
8255 {
8256 constexpr BlockLength offset = 40;
8257
8258 return ordinary(value, offset, NullUTCTimestampNanos());
8259 }
8260
8263 ONIXS_B3_UMDF_MD_NODISCARD
8264 bool rptSeq(RptSeq& value) const
8265 noexcept
8266 {
8267 constexpr BlockLength offset = 48;
8268
8269 return ordinary(value, offset, NullRptSeq());
8270 }
8271
8273 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8274 constexpr
8275 static
8276 BlockLength
8277 minimalBlockLength(
8278 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8279 noexcept
8280 {
8281 return
8282 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8283 52;
8284 }
8285
8287 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8288 constexpr
8289 static BlockLength blockLength(SchemaVersion version)
8290 noexcept
8291 {
8292 return
8293 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8294 minimalBlockLength(version);
8295 }
8296
8298 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8299 ONIXS_B3_UMDF_MD_NODISCARD
8300 constexpr
8301 static
8302 MessageSize
8303 getMinimalVariableFieldsSize(
8304 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8305 {
8306 return
8307 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8308 0;
8309 }
8310
8312 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8313 ONIXS_B3_UMDF_MD_NODISCARD
8314 constexpr
8315 static StrRef className()
8316 noexcept
8317 {
8318 return constructStrRef("ExecutionStatistics_56");
8319 }
8320
8322 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8323 ONIXS_B3_UMDF_MD_NODISCARD
8324 constexpr
8325 static StrRef fixType()
8326 noexcept
8327 {
8328 return constructStrRef("ExecutionStatistics_56");
8329 }
8330
8332 ONIXS_B3_UMDF_MD_NODISCARD
8333 std::string toString() const;
8334
8335private:
8336 void checkLength(
8337 EncodedLength length, SchemaVersion version) const
8338 {
8339 const EncodedLength minimalRequiredLength =
8340 minimalBlockLength(version) +
8341 MessageHeader::Size +
8342 getMinimalVariableFieldsSize(version);
8343
8344 checkBinaryLength(
8345 *this, length, minimalRequiredLength);
8346 }
8347
8348 void checkCompatibility() const
8349 {
8350 assert(TemplateId == templateId());
8351
8352 checkSchema<Schema>(schemaId(), version());
8353 checkLength(bufferSize(), version());
8354 }
8355};
8356
8358ONIXS_B3_UMDF_MD_LTWT_STRUCT
8359TradeBust_57
8360: SbeMessage
8361{
8363 typedef SchemaTraits Schema;
8364
8366 enum { TemplateId = 57 };
8367
8369 TradeBust_57() = default;
8370
8372 TradeBust_57(
8373 void* data,
8374 EncodedLength length,
8375 NoInit)
8376 : SbeMessage(data, length)
8377 {
8378 checkCompatibility();
8379 }
8380
8382 explicit
8383 TradeBust_57(
8384 const SbeMessage& message)
8385 : SbeMessage(message)
8386 {
8387 assert(message.valid());
8388
8389 checkCompatibility();
8390 }
8391
8394 TradeBust_57(
8395 void* data,
8396 EncodedLength length,
8397 NoInit,
8398 NoCheck)
8399 noexcept
8400 : SbeMessage(data, length, NoCheck())
8401 {
8402 assert(schemaId() == Schema::Id);
8403 assert(version() >= Schema::MinimalVersion);
8404 assert(TemplateId == templateId());
8405 }
8406
8408 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8409 constexpr
8415
8418 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8419 constexpr
8420 static ApplVerID::Enum applVerId()
8421 noexcept
8422 {
8423 return ApplVerID::FIX50SP2;
8424 }
8425
8428 ONIXS_B3_UMDF_MD_NODISCARD
8429 SecurityID securityId() const
8430 noexcept
8431 {
8432 constexpr BlockLength offset = 0;
8433
8434 return ordinary<SecurityID>(offset);
8435 }
8436
8438 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8439 constexpr
8445
8447 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8448 ONIXS_B3_UMDF_MD_NODISCARD
8449 constexpr
8450 static StrRef securityExchange()
8451 noexcept
8452 {
8453 return constructStrRef("BVMF");
8454 }
8455
8458 ONIXS_B3_UMDF_MD_NODISCARD
8459 MatchEventIndicator matchEventIndicator() const
8460 noexcept
8461 {
8462 constexpr BlockLength offset = 8;
8463
8464 return ordinary<MatchEventIndicator>(offset);
8465 }
8466
8468 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8469 constexpr
8470 static UpdateAction::Enum mDUpdateAction()
8471 noexcept
8472 {
8473 return UpdateAction::DELETE;
8474 }
8475
8477 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8478 constexpr
8479 static EntryType::Enum mDEntryType()
8480 noexcept
8481 {
8482 return EntryType::TRADE_BUST;
8483 }
8484
8486 ONIXS_B3_UMDF_MD_NODISCARD
8487 TradingSessionID::Enum tradingSessionId() const
8488 noexcept
8489 {
8490 constexpr BlockLength offset = 9;
8491
8492 return enumeration<TradingSessionID>(offset);
8493 }
8494
8496 ONIXS_B3_UMDF_MD_NODISCARD
8497 Price mDEntryPx() const
8498 noexcept
8499 {
8500 constexpr BlockLength offset = 12;
8501
8502 return decimal<Price>(offset);
8503 }
8504
8506 ONIXS_B3_UMDF_MD_NODISCARD
8507 Quantity mDEntrySize() const
8508 noexcept
8509 {
8510 constexpr BlockLength offset = 20;
8511
8512 return ordinary<Quantity>(offset);
8513 }
8514
8518 ONIXS_B3_UMDF_MD_NODISCARD
8519 TradeID tradeId() const
8520 noexcept
8521 {
8522 constexpr BlockLength offset = 28;
8523
8524 return ordinary<TradeID>(offset);
8525 }
8526
8529 ONIXS_B3_UMDF_MD_NODISCARD
8530 Timestamp tradeDate() const
8531 noexcept
8532 {
8533 constexpr BlockLength offset = 32;
8534
8535 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
8536 }
8537
8539 ONIXS_B3_UMDF_MD_NODISCARD
8540 bool transactTime(UTCTimestampNanos& value) const
8541 noexcept
8542 {
8543 constexpr BlockLength offset = 36;
8544
8545 return ordinary(value, offset, NullUTCTimestampNanos());
8546 }
8547
8550 ONIXS_B3_UMDF_MD_NODISCARD
8551 bool rptSeq(RptSeq& value) const
8552 noexcept
8553 {
8554 constexpr BlockLength offset = 44;
8555
8556 return ordinary(value, offset, NullRptSeq());
8557 }
8558
8560 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8561 constexpr
8562 static
8563 BlockLength
8564 minimalBlockLength(
8565 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8566 noexcept
8567 {
8568 return
8569 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8570 48;
8571 }
8572
8574 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8575 constexpr
8576 static
8577 BlockLength
8578 blockLength(
8579 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8580 noexcept
8581 {
8582 return
8583 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8584 minimalBlockLength(version);
8585 }
8586
8588 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8589 ONIXS_B3_UMDF_MD_NODISCARD
8590 constexpr
8591 static
8592 MessageSize
8593 getMinimalVariableFieldsSize(
8594 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8595 {
8596 return
8597 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8598 0;
8599 }
8600
8602 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8603 ONIXS_B3_UMDF_MD_NODISCARD
8604 constexpr
8605 static StrRef className()
8606 noexcept
8607 {
8608 return constructStrRef("TradeBust_57");
8609 }
8610
8612 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8613 ONIXS_B3_UMDF_MD_NODISCARD
8614 constexpr
8615 static StrRef fixType()
8616 noexcept
8617 {
8618 return constructStrRef("TradeBust_57");
8619 }
8620
8622 ONIXS_B3_UMDF_MD_NODISCARD
8623 std::string toString() const;
8624
8625private:
8626 void checkLength(
8627 EncodedLength length, SchemaVersion version) const
8628 {
8629 const EncodedLength minimalRequiredLength =
8630 minimalBlockLength(version) +
8631 MessageHeader::Size +
8632 getMinimalVariableFieldsSize(version);
8633
8634 checkBinaryLength(
8635 *this, length, minimalRequiredLength);
8636 }
8637
8638 void checkCompatibility() const
8639 {
8640 assert(TemplateId == templateId());
8641
8642 checkSchema<Schema>(schemaId(), version());
8643 checkLength(bufferSize(), version());
8644 }
8645};
8646
8648ONIXS_B3_UMDF_MD_LTWT_STRUCT
8649SnapshotFullRefresh_Orders_MBO_71
8650: SbeMessage
8651{
8653 typedef SchemaTraits Schema;
8654
8656 enum { TemplateId = 71 };
8657
8660 ONIXS_B3_UMDF_MD_LTWT_STRUCT
8661 Entry : SbeGroupEntry
8662 <
8663 GroupSizeEncoding::BlockLength
8664 >
8665 {
8667 typedef
8668 SbeGroupEntry
8669 <
8670 GroupSizeEncoding::BlockLength
8671 >
8672 Base;
8673
8676 Entry(
8677 const void* data,
8678 EncodedLength length,
8679 SchemaVersion version)
8680 : Base(data, numericCast<Base::BlockLength>(length), version)
8681 {
8682 assert(version >= Schema::MinimalVersion);
8683 assert(length >= minimalBlockLength(version));
8684 }
8685
8688 ONIXS_B3_UMDF_MD_NODISCARD
8689 bool mDEntryPx(PriceOptional& value) const
8690 noexcept
8691 {
8692 constexpr BlockLength offset = 0;
8693
8694 return decimal(value, offset, NullPriceOptional());
8695 }
8696
8699 ONIXS_B3_UMDF_MD_NODISCARD
8700 Quantity mDEntrySize() const
8701 noexcept
8702 {
8703 constexpr BlockLength offset = 8;
8704
8705 return ordinary<Quantity>(offset);
8706 }
8707
8709 ONIXS_B3_UMDF_MD_NODISCARD
8710 bool enteringFirm(FirmOptional& value) const
8711 noexcept
8712 {
8713 constexpr BlockLength offset = 20;
8714
8715 return ordinary(value, offset, NullFirmOptional());
8716 }
8717
8721 ONIXS_B3_UMDF_MD_NODISCARD
8722 bool mDInsertTimestamp(UTCTimestampNanos& value) const
8723 noexcept
8724 {
8725 constexpr BlockLength offset = 24;
8726
8727 return ordinary(value, offset, NullUTCTimestampNanos());
8728 }
8729
8737 ONIXS_B3_UMDF_MD_NODISCARD
8738 OrderID secondaryOrderId() const
8739 noexcept
8740 {
8741 constexpr BlockLength offset = 32;
8742
8743 return ordinary<OrderID>(offset);
8744 }
8745
8747 ONIXS_B3_UMDF_MD_NODISCARD
8748 EntryType::Enum mDEntryType() const
8749 noexcept
8750 {
8751 constexpr BlockLength offset = 40;
8752
8753 return enumeration<EntryType>(offset);
8754 }
8755
8758 ONIXS_B3_UMDF_MD_NODISCARD
8759 MatchEventIndicator matchEventIndicator() const
8760 noexcept
8761 {
8762 constexpr BlockLength offset = 41;
8763
8764 return ordinary<MatchEventIndicator>(offset);
8765 }
8766
8769 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8770 constexpr
8771 static
8772 BlockLength
8773 blockLength(
8774 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8775 noexcept
8776 {
8777 return
8778 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8779 42;
8780 }
8781
8784 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8785 constexpr
8786 static
8787 BlockLength
8788 minimalBlockLength(
8789 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8790 noexcept
8791 {
8792 return
8793 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8794 42;
8795 }
8796
8798 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8799 ONIXS_B3_UMDF_MD_NODISCARD
8800 constexpr
8801 static StrRef className()
8802 noexcept
8803 {
8804 return constructStrRef("SnapshotFullRefresh_Orders_MBO_71.Entry");
8805 }
8806 };
8807
8809 typedef
8810 SbeGroup<Entry, GroupSizeEncoding, MessageSize>
8811 Entries;
8812
8814 SnapshotFullRefresh_Orders_MBO_71() = default;
8815
8817 SnapshotFullRefresh_Orders_MBO_71(
8818 void* data,
8819 EncodedLength length,
8820 NoInit)
8821 : SbeMessage(data, length)
8822 {
8823 checkCompatibility();
8824 }
8825
8827 explicit
8828 SnapshotFullRefresh_Orders_MBO_71(
8829 const SbeMessage& message)
8830 : SbeMessage(message)
8831 {
8832 assert(message.valid());
8833
8834 checkCompatibility();
8835 }
8836
8839 SnapshotFullRefresh_Orders_MBO_71(
8840 void* data,
8841 EncodedLength length,
8842 NoInit,
8843 NoCheck)
8844 noexcept
8845 : SbeMessage(data, length, NoCheck())
8846 {
8847 assert(schemaId() == Schema::Id);
8848 assert(version() >= Schema::MinimalVersion);
8849 assert(TemplateId == templateId());
8850 }
8851
8853 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8854 constexpr
8860
8863 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8864 constexpr
8865 static ApplVerID::Enum applVerId()
8866 noexcept
8867 {
8868 return ApplVerID::FIX50SP2;
8869 }
8870
8873 ONIXS_B3_UMDF_MD_NODISCARD
8874 SecurityID securityId() const
8875 noexcept
8876 {
8877 constexpr BlockLength offset = 0;
8878
8879 return ordinary<SecurityID>(offset);
8880 }
8881
8883 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8884 constexpr
8890
8892 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8893 ONIXS_B3_UMDF_MD_NODISCARD
8894 constexpr
8895 static StrRef securityExchange()
8896 noexcept
8897 {
8898 return constructStrRef("BVMF");
8899 }
8900
8902 ONIXS_B3_UMDF_MD_NODISCARD
8903 Entries entries() const
8904 noexcept
8905 {
8906 return getGroup<Entries>(EntriesAccess(), *this);
8907 }
8908
8910 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8911 constexpr
8912 static
8913 BlockLength
8914 minimalBlockLength(
8915 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8916 noexcept
8917 {
8918 return
8919 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8920 8;
8921 }
8922
8924 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8925 constexpr
8933
8935 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8936 ONIXS_B3_UMDF_MD_NODISCARD
8937 constexpr
8938 static
8939 MessageSize
8940 getMinimalVariableFieldsSize(
8941 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8942 {
8943 return
8944 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8945 static_cast<MessageSize>(Entries::EmptySize);
8946 }
8947
8949 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8950 ONIXS_B3_UMDF_MD_NODISCARD
8951 constexpr
8952 static StrRef className()
8953 noexcept
8954 {
8955 return constructStrRef("SnapshotFullRefresh_Orders_MBO_71");
8956 }
8957
8959 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8960 ONIXS_B3_UMDF_MD_NODISCARD
8961 constexpr
8962 static StrRef fixType()
8963 noexcept
8964 {
8965 return constructStrRef(
8966 "SnapshotFullRefresh_Orders_MBO_71");
8967 }
8968
8970 ONIXS_B3_UMDF_MD_NODISCARD
8971 std::string toString() const;
8972
8973private:
8974 void checkLength(
8975 EncodedLength length, SchemaVersion version) const
8976 {
8977 const EncodedLength minimalRequiredLength =
8978 minimalBlockLength(version) +
8979 MessageHeader::Size +
8980 getMinimalVariableFieldsSize(version);
8981
8982 checkBinaryLength(
8983 *this, length, minimalRequiredLength);
8984 }
8985
8987 void checkVarLenFields() const
8988 {
8989 groups().
8990 checkTail<Entries>();
8991 }
8992
8993 void checkCompatibility() const
8994 {
8995 assert(TemplateId == templateId());
8996
8997 checkSchema<Schema>(schemaId(), version());
8998 checkLength(bufferSize(), version());
8999 checkVarLenFields();
9000 }
9001
9003 struct EntriesAccess
9004 {
9005 Entries
9006 operator()(
9007 const SnapshotFullRefresh_Orders_MBO_71& obj) const
9008 noexcept
9009 {
9010 return obj.
9011 groups().
9012 head<Entries>();
9013 }
9014 };
9015};
9016
9017
9018ONIXS_B3_UMDF_MD_MESSAGING_NAMESPACE_END
ONIXS_B3_UMDF_MD_MESSAGING_NAMESPACE_END
#define ONIXS_B3_UMDF_MD_MESSAGING_NAMESPACE_END
Definition ABI.h:158
ONIXS_B3_UMDF_MD_LTWT_EXPORTED
#define ONIXS_B3_UMDF_MD_LTWT_EXPORTED
Definition ABI.h:96
ONIXS_B3_UMDF_MD_LTWT_STRUCT
#define ONIXS_B3_UMDF_MD_LTWT_STRUCT
Definition ABI.h:93
ONIXS_B3_UMDF_MD_MESSAGING_NAMESPACE_BEGIN
#define ONIXS_B3_UMDF_MD_MESSAGING_NAMESPACE_BEGIN
Definition ABI.h:153
ONIXS_B3_UMDF_MD_ASSERT
#define ONIXS_B3_UMDF_MD_ASSERT(CHECK)
Definition Compiler.h:123
OnixS::B3::MarketData::UMDF::Messaging::SbeFields::assert
assert(value.size()<=Size &&"The string is truncated.")
OnixS::B3::MarketData::UMDF::Messaging::SbeMessage::templateId
MessageTemplateId templateId() const noexcept
Definition SbeMessage.h:1190
OnixS::B3::MarketData::UMDF::Messaging::SbeMessage::getGroup
Group getGroup(Callable callable, Owner &owner) const noexcept
Definition SbeMessage.h:1513
OnixS::B3::MarketData::UMDF::Messaging::SbeMessage::EncodedLength
MessageSize EncodedLength
Length of the message binary data.
Definition SbeMessage.h:1117
OnixS::B3::MarketData::UMDF::Messaging::SbeMessage::SbeMessage
SbeMessage() noexcept
Initializes a blank instance.
Definition SbeMessage.h:1123
OnixS::B3::MarketData::UMDF::Messaging::SbeMessage::BlockLength
MessageSize BlockLength
Length of the message body representing a block of fixed-length fields.
Definition SbeMessage.h:1120
OnixS::B3::MarketData::UMDF::Messaging::UTCTimestampNanos
UTC timestamp with nanosecond precision (Unix Epoch).
Definition Composites.h:615
OnixS::B3::MarketData::UMDF::Timestamp
Represents time point without time-zone information.
Definition Time.h:483
OnixS::B3::MarketData::UMDF::Messaging::className
ONIXS_B3_UMDF_MD_API MessageSize StrRef className
Definition ExceptionHelpers.h:57
OnixS::B3::MarketData::UMDF::Messaging::SeqNum
UInt32 SeqNum
Sequence number inside the given channel.
Definition Fields.h:154
OnixS::B3::MarketData::UMDF::Messaging::NullUInt32NULL
IntegralConstant< UInt32, 0 > NullUInt32NULL
Null value for an optional UInt32NULL field.
Definition Fields.h:1860
OnixS::B3::MarketData::UMDF::Messaging::NullRptSeq
IntegralConstant< UInt32, 0 > NullRptSeq
Null value for an optional RptSeq field.
Definition Fields.h:1944
OnixS::B3::MarketData::UMDF::Messaging::Price8
FixedPointDecimal< Int64, IntegralConstant< Int8, -8 > > Price8
Price (8 decimal places).
Definition Composites.h:439
OnixS::B3::MarketData::UMDF::Messaging::UInt16NULL
UInt16 UInt16NULL
2-byte unsigned integer, from 1 to 65535, NULL (optional) value = 0.
Definition Fields.h:90
OnixS::B3::MarketData::UMDF::Messaging::OrderID
UInt64 OrderID
Unique identifier for Order as assigned by the exchange.
Definition Fields.h:142
OnixS::B3::MarketData::UMDF::Messaging::NullSecurityIDOptional
IntegralConstant< UInt64, 0ULL > NullSecurityIDOptional
Null value for an optional SecurityIDOptional field.
Definition Fields.h:1938
OnixS::B3::MarketData::UMDF::Messaging::SeqNum1
IntegralConstant< UInt32, 1 > SeqNum1
Sequence Number, fixed to 1.
Definition Fields.h:162
OnixS::B3::MarketData::UMDF::Messaging::RatioQty
FixedPointDecimal< Int64, IntegralConstant< Int8, -7 > > RatioQty
Ratio of quantity relative to the whole thing.
Definition Composites.h:305
OnixS::B3::MarketData::UMDF::Messaging::SecurityIDOptional
UInt64 SecurityIDOptional
Security ID as defined by B3's Trading System.
Definition Fields.h:174
OnixS::B3::MarketData::UMDF::Messaging::Price
FixedPointDecimal< Int64, IntegralConstant< Int8, -4 > > Price
Price (4 decimal places).
Definition Composites.h:148
OnixS::B3::MarketData::UMDF::Messaging::NullUInt64NULL
IntegralConstant< UInt64, 0ULL > NullUInt64NULL
Null value for an optional UInt64NULL field.
Definition Fields.h:1866
OnixS::B3::MarketData::UMDF::Messaging::SecurityID
UInt64 SecurityID
Security ID as defined by B3's Trading System.
Definition Fields.h:168
OnixS::B3::MarketData::UMDF::Messaging::NullFirmOptional
IntegralConstant< UInt32, 0 > NullFirmOptional
Null value for an optional FirmOptional field.
Definition Fields.h:1902
OnixS::B3::MarketData::UMDF::Messaging::NullClearingHouseID
IntegralConstant< UInt64, 0ULL > NullClearingHouseID
Null value for an optional ClearingHouseID field.
Definition Fields.h:1950
OnixS::B3::MarketData::UMDF::Messaging::SchemaVersion
MessageHeader::Version SchemaVersion
SBE-encoded data version type.
Definition SchemaTraits.h:30
OnixS::B3::MarketData::UMDF::Messaging::NullUInt8
IntegralConstant< UInt8, 255 > NullUInt8
Null value for an optional UInt8 field.
Definition Fields.h:1794
OnixS::B3::MarketData::UMDF::Messaging::RptSeq
UInt32 RptSeq
Sequence number per instrument update.
Definition Fields.h:186
OnixS::B3::MarketData::UMDF::Messaging::LocalMktDate32Optional
Int32 LocalMktDate32Optional
Optional local date (as opposed to UTC).
Definition Fields.h:234
OnixS::B3::MarketData::UMDF::Messaging::NullLocalMktDate32Optional
IntegralConstant< Int32, 0 > NullLocalMktDate32Optional
Null value for an optional LocalMktDate32Optional field.
Definition Fields.h:1986
OnixS::B3::MarketData::UMDF::Messaging::MessageSize
UInt16 MessageSize
Message length type.
Definition Aliases.h:29
OnixS::B3::MarketData::UMDF::Messaging::NullQuantityOptional
IntegralConstant< Int64, -9223372036854775807LL-1 > NullQuantityOptional
Null value for an optional QuantityOptional field.
Definition Fields.h:1884
OnixS::B3::MarketData::UMDF::Messaging::UInt32
UInt32 UInt32
4-byte unsigned integer, from 0 to 4294967295 (2^32-1).
Definition Fields.h:58
OnixS::B3::MarketData::UMDF::Messaging::QuantityVolumeOptional
Int64 QuantityVolumeOptional
Volume Quantity.
Definition Fields.h:130
OnixS::B3::MarketData::UMDF::Messaging::NullUInt8NULL
IntegralConstant< UInt8, 0 > NullUInt8NULL
Null value for an optional UInt8NULL field.
Definition Fields.h:1848
OnixS::B3::MarketData::UMDF::Messaging::FirmOptional
UInt32 FirmOptional
Identifies the broker firm.
Definition Fields.h:136
OnixS::B3::MarketData::UMDF::Messaging::NullSettlType
IntegralConstant< UInt16, 65535 > NullSettlType
Null value for an optional SettlType field.
Definition Fields.h:1962
OnixS::B3::MarketData::UMDF::Messaging::Quantity
Int64 Quantity
Quantity in order/trade.
Definition Fields.h:110
OnixS::B3::MarketData::UMDF::Messaging::NullQuantityVolumeOptional
IntegralConstant< Int64, -9223372036854775807LL-1 > NullQuantityVolumeOptional
Null value for an optional QuantityVolumeOptional field.
Definition Fields.h:1896
OnixS::B3::MarketData::UMDF::Messaging::PriceOptional
NullableFixedPointDecimal< Int64, IntegralConstant< Int8, -4 >, IntegralConstant< Int64, -9223372036854775807LL-1 > > PriceOptional
Optional price (4 decimal places).
Definition Composites.h:160
OnixS::B3::MarketData::UMDF::Messaging::NullMarketSegmentID
IntegralConstant< UInt8, 0 > NullMarketSegmentID
Null value for an optional MarketSegmentID field.
Definition Fields.h:1998
OnixS::B3::MarketData::UMDF::Messaging::UInt16
UInt16 UInt16
2-byte unsigned integer, from 0 to 65535.
Definition Fields.h:54
OnixS::B3::MarketData::UMDF::Messaging::NullUInt16NULL
IntegralConstant< UInt16, 0 > NullUInt16NULL
Null value for an optional UInt16NULL field.
Definition Fields.h:1854
OnixS::B3::MarketData::UMDF::UInt16
Messaging::UInt16 UInt16
Definition Integral.h:34
OnixS::B3::MarketData::UMDF::Price
Messaging::PriceOptional Price
Alias for Price type (4 decimal places)
Definition OrderBook.h:133
OnixS::B3::MarketData::UMDF::Quantity
Int64 Quantity
Alias for Quantity type.
Definition OrderBook.h:130
OnixS::B3::MarketData::UMDF::Messaging::AggressorSide::Enum
Enum
Which side is aggressor of this trade.
Definition Fields.h:758
OnixS::B3::MarketData::UMDF::Messaging::ApplVerID::Enum
Enum
Specifies the service pack release being applied at message level.
Definition Fields.h:1192
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::AuctionImbalance_19
AuctionImbalance_19(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:3759
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::AuctionImbalance_19
AuctionImbalance_19()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:3750
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:3797
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::TemplateId
@ TemplateId
Definition Messages.h:3753
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::AuctionImbalance_19
AuctionImbalance_19(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:3781
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::AuctionImbalance_19
AuctionImbalance_19(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:3770
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:3827
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:3807
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:664
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::ChannelReset_11
ChannelReset_11(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:607
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::ChannelReset_11
ChannelReset_11()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:598
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:720
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::ChannelReset_11
ChannelReset_11(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:618
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:645
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::TemplateId
@ TemplateId
Definition Messages.h:601
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:706
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::ChannelReset_11
ChannelReset_11(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:629
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Type of the Market Data Entry.
Definition Messages.h:673
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:655
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:3569
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::TemplateId
@ TemplateId
Definition Messages.h:3465
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:3462
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:3509
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::ClosingPrice_17
ClosingPrice_17()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::ClosingPrice_17
ClosingPrice_17(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:3471
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::ClosingPrice_17
ClosingPrice_17(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:3482
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Closing Price.
Definition Messages.h:3578
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::ClosingPrice_17
ClosingPrice_17(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:3493
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:3539
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:3519
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (DELETE).
Definition Messages.h:6685
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::DeleteOrder_MBO_51
DeleteOrder_MBO_51()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::DeleteOrder_MBO_51
DeleteOrder_MBO_51(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:6609
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:6578
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::DeleteOrder_MBO_51
DeleteOrder_MBO_51(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:6587
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::DeleteOrder_MBO_51
DeleteOrder_MBO_51(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:6598
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:6625
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::TemplateId
@ TemplateId
Definition Messages.h:6581
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:6655
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:6635
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:437
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::EmptyBook_9
EmptyBook_9(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:391
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::EmptyBook_9
EmptyBook_9()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::EmptyBook_9
EmptyBook_9(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:380
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:371
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:523
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:418
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::TemplateId
@ TemplateId
Definition Messages.h:374
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:509
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Type of the Market Data Entry.
Definition Messages.h:446
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::EmptyBook_9
EmptyBook_9(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:402
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:466
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:428
OnixS::B3::MarketData::UMDF::Messaging::EntryType::TRADE_BUST
@ TRADE_BUST
Trade busted by Market Supervision.
Definition Fields.h:1112
OnixS::B3::MarketData::UMDF::Messaging::EntryType::EXECUTION_STATISTICS
@ EXECUTION_STATISTICS
Execution Statistics for related Trades.
Definition Fields.h:1079
OnixS::B3::MarketData::UMDF::Messaging::EntryType::TRADE
@ TRADE
Trade or Trade Summary or Last Trade Price.
Definition Fields.h:1058
OnixS::B3::MarketData::UMDF::Messaging::EntryType::EXECUTION_SUMMARY
@ EXECUTION_SUMMARY
Execution Summary for related Trades.
Definition Fields.h:1106
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:8172
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::TemplateId
@ TemplateId
Definition Messages.h:8068
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::ExecutionStatistics_56
ExecutionStatistics_56()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:8065
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::ExecutionStatistics_56
ExecutionStatistics_56(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:8096
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::ExecutionStatistics_56
ExecutionStatistics_56(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:8074
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:8112
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::ExecutionStatistics_56
ExecutionStatistics_56(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:8085
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Execution Statistics.
Definition Messages.h:8181
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:8142
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:8122
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:7872
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::ExecutionSummary_55
ExecutionSummary_55()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:7776
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:7823
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::ExecutionSummary_55
ExecutionSummary_55(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7796
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::TemplateId
@ TemplateId
Definition Messages.h:7779
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::ExecutionSummary_55
ExecutionSummary_55(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:7785
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Execution Summary.
Definition Messages.h:7881
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:7853
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:7833
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::ExecutionSummary_55
ExecutionSummary_55(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:7807
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW).
Definition Messages.h:7528
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::ForwardTrade_54
ForwardTrade_54(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7441
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::ForwardTrade_54
ForwardTrade_54()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::ForwardTrade_54
ForwardTrade_54(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:7452
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::ForwardTrade_54
ForwardTrade_54(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:7430
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:7421
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:7468
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::TemplateId
@ TemplateId
Definition Messages.h:7424
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Trade.
Definition Messages.h:7537
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:7498
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:7478
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::HighPrice_24
HighPrice_24(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:4591
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::HighPrice_24
HighPrice_24(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4602
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:4582
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::HighPrice_24
HighPrice_24()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:4629
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::TemplateId
@ TemplateId
Definition Messages.h:4585
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::HighPrice_24
HighPrice_24(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:4613
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:4659
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:4639
OnixS::B3::MarketData::UMDF::Messaging::InstrAttribType::Enum
Enum
Code to represent the type of instrument attributes.
Definition Fields.h:1297
OnixS::B3::MarketData::UMDF::Messaging::InstrAttribValue::Enum
Enum
Code to represent the type of instrument attributes.
Definition Fields.h:1320
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:5201
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::TemplateId
@ TemplateId
Definition Messages.h:5097
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::LastTradePrice_27
LastTradePrice_27(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:5103
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:5094
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:5141
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::LastTradePrice_27
LastTradePrice_27(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:5114
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::LastTradePrice_27
LastTradePrice_27()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Last Trade Price.
Definition Messages.h:5210
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::LastTradePrice_27
LastTradePrice_27(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:5125
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:5171
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:5151
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::LowPrice_25
LowPrice_25()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:4838
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::LowPrice_25
LowPrice_25(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:4869
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::LowPrice_25
LowPrice_25(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:4847
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:4885
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::LowPrice_25
LowPrice_25(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4858
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::TemplateId
@ TemplateId
Definition Messages.h:4841
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:4915
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:4895
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:6850
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::MassDeleteOrders_MBO_52
MassDeleteOrders_MBO_52(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:6859
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::MassDeleteOrders_MBO_52
MassDeleteOrders_MBO_52()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:6897
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::MassDeleteOrders_MBO_52
MassDeleteOrders_MBO_52(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:6881
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::TemplateId
@ TemplateId
Definition Messages.h:6853
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:6927
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:6907
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::MassDeleteOrders_MBO_52
MassDeleteOrders_MBO_52(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:6870
OnixS::B3::MarketData::UMDF::Messaging::MatchEventIndicator
Set of indicators that identify some market data events.
Definition Fields.h:1677
OnixS::B3::MarketData::UMDF::Messaging::MessageType::Sequence
@ Sequence
Sequence message for heartbeat.
Definition Fields.h:254
OnixS::B3::MarketData::UMDF::Messaging::MessageType::MarketDataIncrementalRefresh
@ MarketDataIncrementalRefresh
Market Data Incremental Refresh.
Definition Fields.h:260
OnixS::B3::MarketData::UMDF::Messaging::MessageType::MarketDataSnapshotFullRefresh
@ MarketDataSnapshotFullRefresh
Market Data Full Refresh.
Definition Fields.h:272
OnixS::B3::MarketData::UMDF::Messaging::News_5::News_5
News_5()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::News_5::TemplateId
@ TemplateId
Definition Messages.h:2561
OnixS::B3::MarketData::UMDF::Messaging::News_5::News_5
News_5(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:2578
OnixS::B3::MarketData::UMDF::Messaging::News_5::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:2558
OnixS::B3::MarketData::UMDF::Messaging::News_5::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:2605
OnixS::B3::MarketData::UMDF::Messaging::News_5::News_5
News_5(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:2567
OnixS::B3::MarketData::UMDF::Messaging::News_5::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:2637
OnixS::B3::MarketData::UMDF::Messaging::News_5::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:2615
OnixS::B3::MarketData::UMDF::Messaging::News_5::News_5
News_5(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:2589
OnixS::B3::MarketData::UMDF::Messaging::NullPriceOptional
Null values definition for optional PriceOptional field.
Definition Composites.h:164
OnixS::B3::MarketData::UMDF::Messaging::NullRatioQty
Null values definition for optional RatioQty field.
Definition Composites.h:309
OnixS::B3::MarketData::UMDF::Messaging::NullUTCTimestampNanos
Null values definition for optional UTCTimestampNanos field.
Definition Composites.h:689
OnixS::B3::MarketData::UMDF::Messaging::OpenCloseSettlFlag::Enum
Enum
Flag that identifies if the opening/closing/settlement price is related to theoretical,...
Definition Fields.h:870
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:5844
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::OpenInterest_29
OpenInterest_29(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:5757
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:5737
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::TemplateId
@ TemplateId
Definition Messages.h:5740
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5920
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::OpenInterest_29
OpenInterest_29(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:5768
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::OpenInterest_29
OpenInterest_29()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:5784
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:5906
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::OpenInterest_29
OpenInterest_29(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:5746
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Open Interest.
Definition Messages.h:5853
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:5814
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:5794
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::OpeningPrice_15
OpeningPrice_15(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:2912
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::OpeningPrice_15
OpeningPrice_15()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::TemplateId
@ TemplateId
Definition Messages.h:2906
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:2903
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:2950
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::OpeningPrice_15
OpeningPrice_15(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:2934
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::OpeningPrice_15
OpeningPrice_15(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:2923
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:2980
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:2960
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::TemplateId
@ TemplateId
Definition Messages.h:6267
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:6264
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:6311
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::Order_MBO_50
Order_MBO_50(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:6284
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::Order_MBO_50
Order_MBO_50(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:6295
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::Order_MBO_50
Order_MBO_50(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:6273
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::Order_MBO_50
Order_MBO_50()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:6341
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:6321
OnixS::B3::MarketData::UMDF::Messaging::PriceBandType::Enum
Enum
Indicates the type of price banding (tunnel).
Definition Fields.h:839
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:4378
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::PriceBand_22
PriceBand_22(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:4280
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::PriceBand_22
PriceBand_22()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::PriceBand_22
PriceBand_22(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:4302
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:4271
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:4318
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::PriceBand_22
PriceBand_22(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4291
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Price Band.
Definition Messages.h:4387
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::TemplateId
@ TemplateId
Definition Messages.h:4274
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:4348
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:4328
OnixS::B3::MarketData::UMDF::Messaging::PriceLimitType::Enum
Enum
Describes how the price limits are expressed.
Definition Fields.h:904
OnixS::B3::MarketData::UMDF::Messaging::PriceType::Enum
Enum
Code to represent the price type. If absent (zero), the default value is DECIMALS.
Definition Fields.h:588
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::QuantityBand_21
QuantityBand_21(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:4015
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:4113
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:4006
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::TemplateId
@ TemplateId
Definition Messages.h:4009
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4196
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::QuantityBand_21
QuantityBand_21(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:4037
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:4053
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4182
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::QuantityBand_21
QuantityBand_21(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:4026
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Quantity Band.
Definition Messages.h:4122
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::QuantityBand_21
QuantityBand_21()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:4083
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:4063
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::InstrAttribsEntry::InstrAttribsEntry
InstrAttribsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:1597
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::InstrAttribsEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:1593
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::LegsEntry
LegsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:1453
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::legSecurityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum legSecurityIdSource() noexcept
Identifies the class of the leg instrument's SecurityID (Exchange Symbol).
Definition Messages.h:1477
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:1449
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1396
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:1337
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Definition Messages.h:1410
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::UnderlyingsEntry
UnderlyingsEntry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:1341
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::underlyingSecurityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum underlyingSecurityIdSource() noexcept
Identifies the class of the underlying instrument's SecurityID (Exchange Symbol).
Definition Messages.h:1365
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::SecurityDefinition_12
SecurityDefinition_12(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:1697
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::SecurityDefinition_12
SecurityDefinition_12(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:1675
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::Underlyings
SbeGroup< UnderlyingsEntry, GroupSizeEncoding, MessageSize > Underlyings
Repeating group containing UnderlyingsEntry entries.
Definition Messages.h:1433
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::Legs
SbeGroup< LegsEntry, GroupSizeEncoding, MessageSize > Legs
Repeating group containing LegsEntry entries.
Definition Messages.h:1576
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::TemplateId
@ TemplateId
Definition Messages.h:1321
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:1318
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::SecurityDefinition_12
SecurityDefinition_12()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:1713
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::SecurityDefinition_12
SecurityDefinition_12(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:1686
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::InstrAttribs
SbeGroup< InstrAttribsEntry, GroupSizeEncoding, MessageSize > InstrAttribs
Repeating group containing InstrAttribsEntry entries.
Definition Messages.h:1669
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:1723
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::SecurityGroupPhase_10
SecurityGroupPhase_10(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:1093
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::SecurityGroupPhase_10
SecurityGroupPhase_10(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:1082
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:1073
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::TemplateId
@ TemplateId
Definition Messages.h:1076
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:1120
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::SecurityGroupPhase_10
SecurityGroupPhase_10(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:1104
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:1130
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::SecurityGroupPhase_10
SecurityGroupPhase_10()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SecurityIDSource::Enum
Enum
Identifies class or source of the SecurityID value.
Definition Fields.h:1354
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::SecurityStatus_3
SecurityStatus_3(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:815
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::TemplateId
@ TemplateId
Definition Messages.h:798
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:795
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:842
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::SecurityStatus_3
SecurityStatus_3(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:804
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::SecurityStatus_3
SecurityStatus_3(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:826
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::SecurityStatus_3
SecurityStatus_3()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:872
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:852
OnixS::B3::MarketData::UMDF::Messaging::SecurityTradingStatus::Enum
Enum
Status related to a given Instrument or phase related to a SecurityGroup where the instrument belongs...
Definition Fields.h:616
OnixS::B3::MarketData::UMDF::Messaging::SecurityType::Enum
Enum
Indicates the type of the security.
Definition Fields.h:470
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::newSeqNo
ONIXS_B3_UMDF_MD_API static constexpr SeqNum1 newSeqNo() noexcept
New sequence number. Always one.
Definition Messages.h:109
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:132
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::SequenceReset_1
SequenceReset_1(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:74
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:43
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::SequenceReset_1
SequenceReset_1()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:90
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:120
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::SequenceReset_1
SequenceReset_1(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:63
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::TemplateId
@ TemplateId
Definition Messages.h:46
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::SequenceReset_1
SequenceReset_1(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:52
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:100
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:297
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::Sequence_2
Sequence_2(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:215
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:206
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:253
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:285
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::TemplateId
@ TemplateId
Definition Messages.h:209
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::Sequence_2
Sequence_2()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::Sequence_2
Sequence_2(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:237
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::Sequence_2
Sequence_2(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:226
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:263
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:5555
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:5448
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::SettlementPrice_28
SettlementPrice_28(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:5479
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::SettlementPrice_28
SettlementPrice_28()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:5495
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::TemplateId
@ TemplateId
Definition Messages.h:5451
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::SettlementPrice_28
SettlementPrice_28(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:5468
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Settlement Price.
Definition Messages.h:5564
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::SettlementPrice_28
SettlementPrice_28(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:5457
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:5525
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:5505
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::SnapshotFullRefresh_Header_30
SnapshotFullRefresh_Header_30(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:6004
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:5995
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6188
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::SnapshotFullRefresh_Header_30
SnapshotFullRefresh_Header_30(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:6026
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:6042
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6174
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::TemplateId
@ TemplateId
Definition Messages.h:5998
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::SnapshotFullRefresh_Header_30
SnapshotFullRefresh_Header_30(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:6015
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::SnapshotFullRefresh_Header_30
SnapshotFullRefresh_Header_30()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:6072
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:6052
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:8672
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::Entry
Entry(const void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition Messages.h:8676
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::SnapshotFullRefresh_Orders_MBO_71
SnapshotFullRefresh_Orders_MBO_71(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:8839
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entries
SbeGroup< Entry, GroupSizeEncoding, MessageSize > Entries
Repeating group containing Entry entries.
Definition Messages.h:8811
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::blockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:8926
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:8653
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::SnapshotFullRefresh_Orders_MBO_71
SnapshotFullRefresh_Orders_MBO_71(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:8828
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:8855
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::minimalBlockLength
ONIXS_B3_UMDF_MD_API static constexpr BlockLength minimalBlockLength(__attribute__((__unused__)) SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:8914
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::SnapshotFullRefresh_Orders_MBO_71
SnapshotFullRefresh_Orders_MBO_71()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::TemplateId
@ TemplateId
Definition Messages.h:8656
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::SnapshotFullRefresh_Orders_MBO_71
SnapshotFullRefresh_Orders_MBO_71(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:8817
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:8885
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:8865
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::TheoreticalOpeningPrice_16
TheoreticalOpeningPrice_16(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:3195
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::TemplateId
@ TemplateId
Definition Messages.h:3189
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:3186
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:3233
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::TheoreticalOpeningPrice_16
TheoreticalOpeningPrice_16(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:3206
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::TheoreticalOpeningPrice_16
TheoreticalOpeningPrice_16(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:3217
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::TheoreticalOpeningPrice_16
TheoreticalOpeningPrice_16()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:3263
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:3243
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::TradeBust_57
TradeBust_57(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:8383
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (DELETE) = always delete.
Definition Messages.h:8470
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::TradeBust_57
TradeBust_57()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::TemplateId
@ TemplateId
Definition Messages.h:8366
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:8363
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:8410
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::TradeBust_57
TradeBust_57(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:8394
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Trade Bust.
Definition Messages.h:8479
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::TradeBust_57
TradeBust_57(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:8372
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:8440
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:8420
OnixS::B3::MarketData::UMDF::Messaging::TradeCondition
Set of conditions describing a trade.
Definition Fields.h:1554
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::mDUpdateAction
ONIXS_B3_UMDF_MD_API static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW).
Definition Messages.h:7197
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::Trade_53
Trade_53(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:7099
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::Trade_53
Trade_53()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::TemplateId
@ TemplateId
Definition Messages.h:7093
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:7090
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::Trade_53
Trade_53(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition Messages.h:7121
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::messageType
ONIXS_B3_UMDF_MD_API static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:7137
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::Trade_53
Trade_53(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:7110
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::mDEntryType
ONIXS_B3_UMDF_MD_API static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Trade.
Definition Messages.h:7206
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::securityIdSource
ONIXS_B3_UMDF_MD_API static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:7167
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::applVerId
ONIXS_B3_UMDF_MD_API static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:7147
OnixS::B3::MarketData::UMDF::Messaging::TradingSessionID::Enum
Enum
Phase related to a SecurityGroup where the instrument belongs to.
Definition Fields.h:786
OnixS::B3::MarketData::UMDF::Messaging::TradingSessionSubID::Enum
Enum
Status related to a given Instrument or phase related to a SecurityGroup where the instrument belongs...
Definition Fields.h:656
OnixS::B3::MarketData::UMDF::Messaging::UpdateAction::Enum
Enum
Types of Market Data update action.
Definition Fields.h:1013