OnixS C++ B3 Binary UMDF Market Data Handler 1.11.1
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
90 static MessageType::Enum messageType()
91 noexcept
92 {
93 return MessageType::SequenceReset;
94 }
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
132 static BlockLength blockLength(SchemaVersion version)
133 noexcept
134 {
135 return
136 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
137 minimalBlockLength(version);
138 }
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
297 static BlockLength blockLength(SchemaVersion version)
298 noexcept
299 {
300 return
301 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
302 minimalBlockLength(version);
303 }
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
418 static MessageType::Enum messageType()
419 noexcept
420 {
421 return MessageType::MarketDataIncrementalRefresh;
422 }
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
466 static SecurityIDSource::Enum securityIdSource()
467 noexcept
468 {
469 return SecurityIDSource::EXCHANGE_SYMBOL;
470 }
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
645 static MessageType::Enum messageType()
646 noexcept
647 {
648 return MessageType::MarketDataIncrementalRefresh;
649 }
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
842 static MessageType::Enum messageType()
843 noexcept
844 {
845 return MessageType::SecurityStatus;
846 }
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
872 static SecurityIDSource::Enum securityIdSource()
873 noexcept
874 {
875 return SecurityIDSource::EXCHANGE_SYMBOL;
876 }
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
1396 static BlockLength blockLength(SchemaVersion version)
1397 noexcept
1398 {
1399 return
1400 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
1401 minimalBlockLength(version);
1402 }
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
1477 static SecurityIDSource::Enum legSecurityIdSource()
1478 noexcept
1479 {
1480 return SecurityIDSource::EXCHANGE_SYMBOL;
1481 }
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
1713 static MessageType::Enum messageType()
1714 noexcept
1715 {
1716 return MessageType::SecurityDefinition;
1717 }
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 Date issueDate() const
1959 noexcept
1960 {
1961 constexpr BlockLength offset = 136;
1962
1963 return Date(ordinary<LocalMktDate32>(offset));
1964 }
1965
1967 ONIXS_B3_UMDF_MD_NODISCARD
1968 bool maturityDate(Date& 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 = Date(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(Date& 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 = Date(fieldValue);
2011 return true;
2012 }
2013 return false;
2014 }
2015
2019 ONIXS_B3_UMDF_MD_NODISCARD
2020 bool endDate(Date& 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 = Date(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(Date& 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 = Date(fieldValue);
2061 return true;
2062 }
2063 return false;
2064 }
2065
2068 ONIXS_B3_UMDF_MD_NODISCARD
2069 bool datedDate(Date& 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 = Date(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
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
2637 static SecurityIDSource::Enum securityIdSource()
2638 noexcept
2639 {
2640 return SecurityIDSource::EXCHANGE_SYMBOL;
2641 }
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
2950 static MessageType::Enum messageType()
2951 noexcept
2952 {
2953 return MessageType::MarketDataIncrementalRefresh;
2954 }
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
2980 static SecurityIDSource::Enum securityIdSource()
2981 noexcept
2982 {
2983 return SecurityIDSource::EXCHANGE_SYMBOL;
2984 }
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
3233 static MessageType::Enum messageType()
3234 noexcept
3235 {
3236 return MessageType::MarketDataIncrementalRefresh;
3237 }
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
3263 static SecurityIDSource::Enum securityIdSource()
3264 noexcept
3265 {
3266 return SecurityIDSource::EXCHANGE_SYMBOL;
3267 }
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
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
3509 static MessageType::Enum messageType()
3510 noexcept
3511 {
3512 return MessageType::MarketDataIncrementalRefresh;
3513 }
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
3539 static SecurityIDSource::Enum securityIdSource()
3540 noexcept
3541 {
3542 return SecurityIDSource::EXCHANGE_SYMBOL;
3543 }
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
3797 static MessageType::Enum messageType()
3798 noexcept
3799 {
3800 return MessageType::MarketDataIncrementalRefresh;
3801 }
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
3827 static SecurityIDSource::Enum securityIdSource()
3828 noexcept
3829 {
3830 return SecurityIDSource::EXCHANGE_SYMBOL;
3831 }
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
4053 static MessageType::Enum messageType()
4054 noexcept
4055 {
4056 return MessageType::MarketDataIncrementalRefresh;
4057 }
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
4083 static SecurityIDSource::Enum securityIdSource()
4084 noexcept
4085 {
4086 return SecurityIDSource::EXCHANGE_SYMBOL;
4087 }
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
4318 static MessageType::Enum messageType()
4319 noexcept
4320 {
4321 return MessageType::MarketDataIncrementalRefresh;
4322 }
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
4348 static SecurityIDSource::Enum securityIdSource()
4349 noexcept
4350 {
4351 return SecurityIDSource::EXCHANGE_SYMBOL;
4352 }
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
4460 ONIXS_B3_UMDF_MD_NODISCARD
4461 bool tradingReferencePrice(Fixed8& value) const
4462 noexcept
4463 {
4464 constexpr BlockLength offset = 28;
4465
4466 return decimal(value, offset, NullFixed8());
4467 }
4468
4470 ONIXS_B3_UMDF_MD_NODISCARD
4471 bool mDEntryTimestamp(UTCTimestampNanos& value) const
4472 noexcept
4473 {
4474 constexpr BlockLength offset = 36;
4475
4476 return ordinary(value, offset, NullUTCTimestampNanos());
4477 }
4478
4481 ONIXS_B3_UMDF_MD_NODISCARD
4482 bool rptSeq(RptSeq& value) const
4483 noexcept
4484 {
4485 constexpr BlockLength offset = 44;
4486
4487 return ordinary(value, offset, NullRptSeq());
4488 }
4489
4491 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4492 constexpr
4493 static
4494 BlockLength
4495 minimalBlockLength(
4496 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4497 noexcept
4498 {
4499 return
4500 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4501 48;
4502 }
4503
4505 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4506 constexpr
4507 static BlockLength blockLength(SchemaVersion version)
4508 noexcept
4509 {
4510 return
4511 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4512 minimalBlockLength(version);
4513 }
4514
4516 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4517 ONIXS_B3_UMDF_MD_NODISCARD
4518 constexpr
4519 static
4520 MessageSize
4521 getMinimalVariableFieldsSize(
4522 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4523 {
4524 return
4525 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4526 0;
4527 }
4528
4530 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4531 ONIXS_B3_UMDF_MD_NODISCARD
4532 constexpr
4533 static StrRef className()
4534 noexcept
4535 {
4536 return constructStrRef("PriceBand_22");
4537 }
4538
4540 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4541 ONIXS_B3_UMDF_MD_NODISCARD
4542 constexpr
4543 static StrRef fixType()
4544 noexcept
4545 {
4546 return constructStrRef("PriceBand_22");
4547 }
4548
4550 ONIXS_B3_UMDF_MD_NODISCARD
4551 std::string toString() const;
4552
4553private:
4554 void checkLength(
4555 EncodedLength length, SchemaVersion version) const
4556 {
4557 const EncodedLength minimalRequiredLength =
4558 minimalBlockLength(version) +
4559 MessageHeader::Size +
4560 getMinimalVariableFieldsSize(version);
4561
4562 checkBinaryLength(
4563 *this, length, minimalRequiredLength);
4564 }
4565
4566 void checkCompatibility() const
4567 {
4568 assert(TemplateId == templateId());
4569
4570 checkSchema<Schema>(schemaId(), version());
4571 checkLength(bufferSize(), version());
4572 }
4573};
4574
4576ONIXS_B3_UMDF_MD_LTWT_STRUCT
4577HighPrice_24
4578: SbeMessage
4579{
4581 typedef SchemaTraits Schema;
4582
4584 enum { TemplateId = 24 };
4585
4587 HighPrice_24() = default;
4588
4590 HighPrice_24(
4591 void* data,
4592 EncodedLength length,
4593 NoInit)
4594 : SbeMessage(data, length)
4595 {
4596 checkCompatibility();
4597 }
4598
4600 explicit
4601 HighPrice_24(
4602 const SbeMessage& message)
4603 : SbeMessage(message)
4604 {
4605 assert(message.valid());
4606
4607 checkCompatibility();
4608 }
4609
4612 HighPrice_24(
4613 void* data,
4614 EncodedLength length,
4615 NoInit,
4616 NoCheck)
4617 noexcept
4618 : SbeMessage(data, length, NoCheck())
4619 {
4620 assert(schemaId() == Schema::Id);
4621 assert(version() >= Schema::MinimalVersion);
4622 assert(TemplateId == templateId());
4623 }
4624
4626 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4627 constexpr
4628 static MessageType::Enum messageType()
4629 noexcept
4630 {
4631 return MessageType::MarketDataIncrementalRefresh;
4632 }
4633
4636 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4637 constexpr
4638 static ApplVerID::Enum applVerId()
4639 noexcept
4640 {
4641 return ApplVerID::FIX50SP2;
4642 }
4643
4646 ONIXS_B3_UMDF_MD_NODISCARD
4647 SecurityID securityId() const
4648 noexcept
4649 {
4650 constexpr BlockLength offset = 0;
4651
4652 return ordinary<SecurityID>(offset);
4653 }
4654
4656 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4657 constexpr
4658 static SecurityIDSource::Enum securityIdSource()
4659 noexcept
4660 {
4661 return SecurityIDSource::EXCHANGE_SYMBOL;
4662 }
4663
4665 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4666 ONIXS_B3_UMDF_MD_NODISCARD
4667 constexpr
4668 static StrRef securityExchange()
4669 noexcept
4670 {
4671 return constructStrRef("BVMF");
4672 }
4673
4676 ONIXS_B3_UMDF_MD_NODISCARD
4677 MatchEventIndicator matchEventIndicator() const
4678 noexcept
4679 {
4680 constexpr BlockLength offset = 8;
4681
4682 return ordinary<MatchEventIndicator>(offset);
4683 }
4684
4686 ONIXS_B3_UMDF_MD_NODISCARD
4687 UpdateAction::Enum mDUpdateAction() const
4688 noexcept
4689 {
4690 constexpr BlockLength offset = 9;
4691
4692 return enumeration<UpdateAction>(offset);
4693 }
4694
4696 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4697 constexpr
4698 static EntryType::Enum mDEntryType()
4699 noexcept
4700 {
4701 return EntryType::SESSION_HIGH_PRICE;
4702 }
4703
4706 ONIXS_B3_UMDF_MD_NODISCARD
4707 Timestamp tradeDate() const
4708 noexcept
4709 {
4710 constexpr BlockLength offset = 10;
4711
4712 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
4713 }
4714
4716 ONIXS_B3_UMDF_MD_NODISCARD
4717 Price mDEntryPx() const
4718 noexcept
4719 {
4720 constexpr BlockLength offset = 12;
4721
4722 return decimal<Price>(offset);
4723 }
4724
4726 ONIXS_B3_UMDF_MD_NODISCARD
4727 bool mDEntryTimestamp(UTCTimestampNanos& value) const
4728 noexcept
4729 {
4730 constexpr BlockLength offset = 20;
4731
4732 return ordinary(value, offset, NullUTCTimestampNanos());
4733 }
4734
4737 ONIXS_B3_UMDF_MD_NODISCARD
4738 bool rptSeq(RptSeq& value) const
4739 noexcept
4740 {
4741 constexpr BlockLength offset = 28;
4742
4743 return ordinary(value, offset, NullRptSeq());
4744 }
4745
4747 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4748 constexpr
4749 static
4750 BlockLength
4751 minimalBlockLength(
4752 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4753 noexcept
4754 {
4755 return
4756 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4757 32;
4758 }
4759
4761 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4762 constexpr
4763 static BlockLength blockLength(SchemaVersion version)
4764 noexcept
4765 {
4766 return
4767 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4768 minimalBlockLength(version);
4769 }
4770
4772 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4773 ONIXS_B3_UMDF_MD_NODISCARD
4774 constexpr
4775 static
4776 MessageSize
4777 getMinimalVariableFieldsSize(
4778 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
4779 {
4780 return
4781 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
4782 0;
4783 }
4784
4786 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4787 ONIXS_B3_UMDF_MD_NODISCARD
4788 constexpr
4789 static StrRef className()
4790 noexcept
4791 {
4792 return constructStrRef("HighPrice_24");
4793 }
4794
4796 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4797 ONIXS_B3_UMDF_MD_NODISCARD
4798 constexpr
4799 static StrRef fixType()
4800 noexcept
4801 {
4802 return constructStrRef("HighPrice_24");
4803 }
4804
4806 ONIXS_B3_UMDF_MD_NODISCARD
4807 std::string toString() const;
4808
4809private:
4810 void checkLength(
4811 EncodedLength length, SchemaVersion version) const
4812 {
4813 const EncodedLength minimalRequiredLength =
4814 minimalBlockLength(version) +
4815 MessageHeader::Size +
4816 getMinimalVariableFieldsSize(version);
4817
4818 checkBinaryLength(
4819 *this, length, minimalRequiredLength);
4820 }
4821
4822 void checkCompatibility() const
4823 {
4824 assert(TemplateId == templateId());
4825
4826 checkSchema<Schema>(schemaId(), version());
4827 checkLength(bufferSize(), version());
4828 }
4829};
4830
4832ONIXS_B3_UMDF_MD_LTWT_STRUCT
4833LowPrice_25
4834: SbeMessage
4835{
4837 typedef SchemaTraits Schema;
4838
4840 enum { TemplateId = 25 };
4841
4843 LowPrice_25() = default;
4844
4846 LowPrice_25(
4847 void* data,
4848 EncodedLength length,
4849 NoInit)
4850 : SbeMessage(data, length)
4851 {
4852 checkCompatibility();
4853 }
4854
4856 explicit
4857 LowPrice_25(
4858 const SbeMessage& message)
4859 : SbeMessage(message)
4860 {
4861 assert(message.valid());
4862
4863 checkCompatibility();
4864 }
4865
4868 LowPrice_25(
4869 void* data,
4870 EncodedLength length,
4871 NoInit,
4872 NoCheck)
4873 noexcept
4874 : SbeMessage(data, length, NoCheck())
4875 {
4876 assert(schemaId() == Schema::Id);
4877 assert(version() >= Schema::MinimalVersion);
4878 assert(TemplateId == templateId());
4879 }
4880
4882 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4883 constexpr
4884 static MessageType::Enum messageType()
4885 noexcept
4886 {
4887 return MessageType::MarketDataIncrementalRefresh;
4888 }
4889
4892 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4893 constexpr
4894 static ApplVerID::Enum applVerId()
4895 noexcept
4896 {
4897 return ApplVerID::FIX50SP2;
4898 }
4899
4902 ONIXS_B3_UMDF_MD_NODISCARD
4903 SecurityID securityId() const
4904 noexcept
4905 {
4906 constexpr BlockLength offset = 0;
4907
4908 return ordinary<SecurityID>(offset);
4909 }
4910
4912 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4913 constexpr
4914 static SecurityIDSource::Enum securityIdSource()
4915 noexcept
4916 {
4917 return SecurityIDSource::EXCHANGE_SYMBOL;
4918 }
4919
4921 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4922 ONIXS_B3_UMDF_MD_NODISCARD
4923 constexpr
4924 static StrRef securityExchange()
4925 noexcept
4926 {
4927 return constructStrRef("BVMF");
4928 }
4929
4932 ONIXS_B3_UMDF_MD_NODISCARD
4933 MatchEventIndicator matchEventIndicator() const
4934 noexcept
4935 {
4936 constexpr BlockLength offset = 8;
4937
4938 return ordinary<MatchEventIndicator>(offset);
4939 }
4940
4942 ONIXS_B3_UMDF_MD_NODISCARD
4943 UpdateAction::Enum mDUpdateAction() const
4944 noexcept
4945 {
4946 constexpr BlockLength offset = 9;
4947
4948 return enumeration<UpdateAction>(offset);
4949 }
4950
4952 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
4953 constexpr
4954 static EntryType::Enum mDEntryType()
4955 noexcept
4956 {
4957 return EntryType::SESSION_LOW_PRICE;
4958 }
4959
4962 ONIXS_B3_UMDF_MD_NODISCARD
4963 Timestamp tradeDate() const
4964 noexcept
4965 {
4966 constexpr BlockLength offset = 10;
4967
4968 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
4969 }
4970
4972 ONIXS_B3_UMDF_MD_NODISCARD
4973 Price mDEntryPx() const
4974 noexcept
4975 {
4976 constexpr BlockLength offset = 12;
4977
4978 return decimal<Price>(offset);
4979 }
4980
4982 ONIXS_B3_UMDF_MD_NODISCARD
4983 bool mDEntryTimestamp(UTCTimestampNanos& value) const
4984 noexcept
4985 {
4986 constexpr BlockLength offset = 20;
4987
4988 return ordinary(value, offset, NullUTCTimestampNanos());
4989 }
4990
4993 ONIXS_B3_UMDF_MD_NODISCARD
4994 bool rptSeq(RptSeq& value) const
4995 noexcept
4996 {
4997 constexpr BlockLength offset = 28;
4998
4999 return ordinary(value, offset, NullRptSeq());
5000 }
5001
5003 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5004 constexpr
5005 static
5006 BlockLength
5007 minimalBlockLength(
5008 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5009 noexcept
5010 {
5011 return
5012 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5013 32;
5014 }
5015
5017 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5018 constexpr
5019 static BlockLength blockLength(SchemaVersion version)
5020 noexcept
5021 {
5022 return
5023 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5024 minimalBlockLength(version);
5025 }
5026
5028 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5029 ONIXS_B3_UMDF_MD_NODISCARD
5030 constexpr
5031 static
5032 MessageSize
5033 getMinimalVariableFieldsSize(
5034 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5035 {
5036 return
5037 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5038 0;
5039 }
5040
5042 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5043 ONIXS_B3_UMDF_MD_NODISCARD
5044 constexpr
5045 static StrRef className()
5046 noexcept
5047 {
5048 return constructStrRef("LowPrice_25");
5049 }
5050
5052 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5053 ONIXS_B3_UMDF_MD_NODISCARD
5054 constexpr
5055 static StrRef fixType()
5056 noexcept
5057 {
5058 return constructStrRef("LowPrice_25");
5059 }
5060
5062 ONIXS_B3_UMDF_MD_NODISCARD
5063 std::string toString() const;
5064
5065private:
5066 void checkLength(
5067 EncodedLength length, SchemaVersion version) const
5068 {
5069 const EncodedLength minimalRequiredLength =
5070 minimalBlockLength(version) +
5071 MessageHeader::Size +
5072 getMinimalVariableFieldsSize(version);
5073
5074 checkBinaryLength(
5075 *this, length, minimalRequiredLength);
5076 }
5077
5078 void checkCompatibility() const
5079 {
5080 assert(TemplateId == templateId());
5081
5082 checkSchema<Schema>(schemaId(), version());
5083 checkLength(bufferSize(), version());
5084 }
5085};
5086
5088ONIXS_B3_UMDF_MD_LTWT_STRUCT
5089LastTradePrice_27
5090: SbeMessage
5091{
5093 typedef SchemaTraits Schema;
5094
5096 enum { TemplateId = 27 };
5097
5099 LastTradePrice_27() = default;
5100
5102 LastTradePrice_27(
5103 void* data,
5104 EncodedLength length,
5105 NoInit)
5106 : SbeMessage(data, length)
5107 {
5108 checkCompatibility();
5109 }
5110
5112 explicit
5113 LastTradePrice_27(
5114 const SbeMessage& message)
5115 : SbeMessage(message)
5116 {
5117 assert(message.valid());
5118
5119 checkCompatibility();
5120 }
5121
5124 LastTradePrice_27(
5125 void* data,
5126 EncodedLength length,
5127 NoInit,
5128 NoCheck)
5129 noexcept
5130 : SbeMessage(data, length, NoCheck())
5131 {
5132 assert(schemaId() == Schema::Id);
5133 assert(version() >= Schema::MinimalVersion);
5134 assert(TemplateId == templateId());
5135 }
5136
5138 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5139 constexpr
5140 static MessageType::Enum messageType()
5141 noexcept
5142 {
5143 return MessageType::MarketDataIncrementalRefresh;
5144 }
5145
5148 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5149 constexpr
5150 static ApplVerID::Enum applVerId()
5151 noexcept
5152 {
5153 return ApplVerID::FIX50SP2;
5154 }
5155
5158 ONIXS_B3_UMDF_MD_NODISCARD
5159 SecurityID securityId() const
5160 noexcept
5161 {
5162 constexpr BlockLength offset = 0;
5163
5164 return ordinary<SecurityID>(offset);
5165 }
5166
5168 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5169 constexpr
5170 static SecurityIDSource::Enum securityIdSource()
5171 noexcept
5172 {
5173 return SecurityIDSource::EXCHANGE_SYMBOL;
5174 }
5175
5177 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5178 ONIXS_B3_UMDF_MD_NODISCARD
5179 constexpr
5180 static StrRef securityExchange()
5181 noexcept
5182 {
5183 return constructStrRef("BVMF");
5184 }
5185
5188 ONIXS_B3_UMDF_MD_NODISCARD
5189 MatchEventIndicator matchEventIndicator() const
5190 noexcept
5191 {
5192 constexpr BlockLength offset = 8;
5193
5194 return ordinary<MatchEventIndicator>(offset);
5195 }
5196
5198 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5199 constexpr
5200 static UpdateAction::Enum mDUpdateAction()
5201 noexcept
5202 {
5203 return UpdateAction::NEW;
5204 }
5205
5207 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5208 constexpr
5209 static EntryType::Enum mDEntryType()
5210 noexcept
5211 {
5212 return EntryType::TRADE;
5213 }
5214
5216 ONIXS_B3_UMDF_MD_NODISCARD
5217 TradingSessionID::Enum tradingSessionId() const
5218 noexcept
5219 {
5220 constexpr BlockLength offset = 9;
5221
5222 return enumeration<TradingSessionID>(offset);
5223 }
5224
5226 ONIXS_B3_UMDF_MD_NODISCARD
5227 TradeCondition tradeCondition() const
5228 noexcept
5229 {
5230 constexpr BlockLength offset = 10;
5231
5232 return ordinary<TradeCondition>(offset);
5233 }
5234
5236 ONIXS_B3_UMDF_MD_NODISCARD
5237 Price mDEntryPx() const
5238 noexcept
5239 {
5240 constexpr BlockLength offset = 12;
5241
5242 return decimal<Price>(offset);
5243 }
5244
5246 ONIXS_B3_UMDF_MD_NODISCARD
5247 Quantity mDEntrySize() const
5248 noexcept
5249 {
5250 constexpr BlockLength offset = 20;
5251
5252 return ordinary<Quantity>(offset);
5253 }
5254
5258 ONIXS_B3_UMDF_MD_NODISCARD
5259 TradeID tradeId() const
5260 noexcept
5261 {
5262 constexpr BlockLength offset = 28;
5263
5264 return ordinary<TradeID>(offset);
5265 }
5266
5268 ONIXS_B3_UMDF_MD_NODISCARD
5269 bool mDEntryBuyer(FirmOptional& value) const
5270 noexcept
5271 {
5272 constexpr BlockLength offset = 32;
5273
5274 return ordinary(value, offset, NullFirmOptional());
5275 }
5276
5278 ONIXS_B3_UMDF_MD_NODISCARD
5279 bool mDEntrySeller(FirmOptional& value) const
5280 noexcept
5281 {
5282 constexpr BlockLength offset = 36;
5283
5284 return ordinary(value, offset, NullFirmOptional());
5285 }
5286
5289 ONIXS_B3_UMDF_MD_NODISCARD
5290 Timestamp tradeDate() const
5291 noexcept
5292 {
5293 constexpr BlockLength offset = 40;
5294
5295 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
5296 }
5297
5299 ONIXS_B3_UMDF_MD_NODISCARD
5300 bool mDEntryTimestamp(UTCTimestampNanos& value) const
5301 noexcept
5302 {
5303 constexpr BlockLength offset = 42;
5304
5305 return ordinary(value, offset, NullUTCTimestampNanos());
5306 }
5307
5310 ONIXS_B3_UMDF_MD_NODISCARD
5311 bool rptSeq(RptSeq& value) const
5312 noexcept
5313 {
5314 constexpr BlockLength offset = 50;
5315
5316 return ordinary(value, offset, NullRptSeq());
5317 }
5318
5322 ONIXS_B3_UMDF_MD_NODISCARD
5323 bool sellerDays(UInt16NULL& value) const
5324 noexcept
5325 {
5326 constexpr BlockLength offset = 54;
5327
5328 return ordinary(value, offset, NullUInt16NULL());
5329 }
5330
5334 ONIXS_B3_UMDF_MD_NODISCARD
5335 bool mDEntryInterestRate(Percentage& value) const
5336 noexcept
5337 {
5338 constexpr BlockLength offset = 56;
5339
5340 return decimal(value, offset, NullPercentage());
5341 }
5342
5344 ONIXS_B3_UMDF_MD_NODISCARD
5345 bool trdSubType(TrdSubType::Enum& value) const
5346 noexcept
5347 {
5348 constexpr BlockLength offset = 64;
5349
5350 return enumeration<TrdSubType>(value, offset, NullUInt8NULL());
5351 }
5352
5354 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5355 constexpr
5356 static
5357 BlockLength
5358 minimalBlockLength(
5359 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5360 noexcept
5361 {
5362 return
5363 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5364 68;
5365 }
5366
5368 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5369 constexpr
5370 static
5371 BlockLength
5372 blockLength(
5373 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5374 noexcept
5375 {
5376 return
5377 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5378 68;
5379 }
5380
5382 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5383 ONIXS_B3_UMDF_MD_NODISCARD
5384 constexpr
5385 static
5386 MessageSize
5387 getMinimalVariableFieldsSize(
5388 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5389 {
5390 return
5391 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5392 0;
5393 }
5394
5396 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5397 ONIXS_B3_UMDF_MD_NODISCARD
5398 constexpr
5399 static StrRef className()
5400 noexcept
5401 {
5402 return constructStrRef("LastTradePrice_27");
5403 }
5404
5406 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5407 ONIXS_B3_UMDF_MD_NODISCARD
5408 constexpr
5409 static StrRef fixType()
5410 noexcept
5411 {
5412 return constructStrRef("LastTradePrice_27");
5413 }
5414
5416 ONIXS_B3_UMDF_MD_NODISCARD
5417 std::string toString() const;
5418
5419private:
5420 void checkLength(
5421 EncodedLength length, SchemaVersion version) const
5422 {
5423 const EncodedLength minimalRequiredLength =
5424 minimalBlockLength(version) +
5425 MessageHeader::Size +
5426 getMinimalVariableFieldsSize(version);
5427
5428 checkBinaryLength(
5429 *this, length, minimalRequiredLength);
5430 }
5431
5432 void checkCompatibility() const
5433 {
5434 assert(TemplateId == templateId());
5435
5436 checkSchema<Schema>(schemaId(), version());
5437 checkLength(bufferSize(), version());
5438 }
5439};
5440
5442ONIXS_B3_UMDF_MD_LTWT_STRUCT
5443SettlementPrice_28
5444: SbeMessage
5445{
5447 typedef SchemaTraits Schema;
5448
5450 enum { TemplateId = 28 };
5451
5453 SettlementPrice_28() = default;
5454
5456 SettlementPrice_28(
5457 void* data,
5458 EncodedLength length,
5459 NoInit)
5460 : SbeMessage(data, length)
5461 {
5462 checkCompatibility();
5463 }
5464
5466 explicit
5467 SettlementPrice_28(
5468 const SbeMessage& message)
5469 : SbeMessage(message)
5470 {
5471 assert(message.valid());
5472
5473 checkCompatibility();
5474 }
5475
5478 SettlementPrice_28(
5479 void* data,
5480 EncodedLength length,
5481 NoInit,
5482 NoCheck)
5483 noexcept
5484 : SbeMessage(data, length, NoCheck())
5485 {
5486 assert(schemaId() == Schema::Id);
5487 assert(version() >= Schema::MinimalVersion);
5488 assert(TemplateId == templateId());
5489 }
5490
5492 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5493 constexpr
5494 static MessageType::Enum messageType()
5495 noexcept
5496 {
5497 return MessageType::MarketDataIncrementalRefresh;
5498 }
5499
5502 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5503 constexpr
5504 static ApplVerID::Enum applVerId()
5505 noexcept
5506 {
5507 return ApplVerID::FIX50SP2;
5508 }
5509
5512 ONIXS_B3_UMDF_MD_NODISCARD
5513 SecurityID securityId() const
5514 noexcept
5515 {
5516 constexpr BlockLength offset = 0;
5517
5518 return ordinary<SecurityID>(offset);
5519 }
5520
5522 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5523 constexpr
5524 static SecurityIDSource::Enum securityIdSource()
5525 noexcept
5526 {
5527 return SecurityIDSource::EXCHANGE_SYMBOL;
5528 }
5529
5531 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5532 ONIXS_B3_UMDF_MD_NODISCARD
5533 constexpr
5534 static StrRef securityExchange()
5535 noexcept
5536 {
5537 return constructStrRef("BVMF");
5538 }
5539
5542 ONIXS_B3_UMDF_MD_NODISCARD
5543 MatchEventIndicator matchEventIndicator() const
5544 noexcept
5545 {
5546 constexpr BlockLength offset = 8;
5547
5548 return ordinary<MatchEventIndicator>(offset);
5549 }
5550
5552 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5553 constexpr
5554 static UpdateAction::Enum mDUpdateAction()
5555 noexcept
5556 {
5557 return UpdateAction::NEW;
5558 }
5559
5561 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5562 constexpr
5563 static EntryType::Enum mDEntryType()
5564 noexcept
5565 {
5566 return EntryType::SETTLEMENT_PRICE;
5567 }
5568
5571 ONIXS_B3_UMDF_MD_NODISCARD
5572 Timestamp tradeDate() const
5573 noexcept
5574 {
5575 constexpr BlockLength offset = 10;
5576
5577 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
5578 }
5579
5581 ONIXS_B3_UMDF_MD_NODISCARD
5582 Price mDEntryPx() const
5583 noexcept
5584 {
5585 constexpr BlockLength offset = 12;
5586
5587 return decimal<Price>(offset);
5588 }
5589
5591 ONIXS_B3_UMDF_MD_NODISCARD
5592 bool mDEntryTimestamp(UTCTimestampNanos& value) const
5593 noexcept
5594 {
5595 constexpr BlockLength offset = 20;
5596
5597 return ordinary(value, offset, NullUTCTimestampNanos());
5598 }
5599
5602 ONIXS_B3_UMDF_MD_NODISCARD
5603 bool
5604 openCloseSettlFlag(
5605 OpenCloseSettlFlag::Enum& value) const
5606 noexcept
5607 {
5608 constexpr BlockLength offset = 28;
5609
5610 return enumeration<OpenCloseSettlFlag>(value, offset, NullUInt8());
5611 }
5612
5614 ONIXS_B3_UMDF_MD_NODISCARD
5615 bool priceType(PriceType::Enum& value) const
5616 noexcept
5617 {
5618 constexpr BlockLength offset = 29;
5619
5620 return enumeration<PriceType>(value, offset, NullUInt8NULL());
5621 }
5622
5624 ONIXS_B3_UMDF_MD_NODISCARD
5625 SettlPriceType::Enum settlPriceType() const
5626 noexcept
5627 {
5628 constexpr BlockLength offset = 30;
5629
5630 return enumeration<SettlPriceType>(offset);
5631 }
5632
5635 ONIXS_B3_UMDF_MD_NODISCARD
5636 bool rptSeq(RptSeq& value) const
5637 noexcept
5638 {
5639 constexpr BlockLength offset = 31;
5640
5641 return ordinary(value, offset, NullRptSeq());
5642 }
5643
5645 ONIXS_B3_UMDF_MD_NODISCARD
5646 bool settlDate(Timestamp& value) const
5647 noexcept
5648 {
5649 typedef LocalMktDate FieldValue;
5650
5651 constexpr BlockLength offset = 35;
5652 constexpr SchemaVersion since = 17;
5653
5654 FieldValue fieldValue;
5655
5656 if (ordinary(fieldValue, offset, NullLocalMktDate(), since))
5657 {
5658 value = localMktDateToTimestamp(fieldValue);
5659 return true;
5660 }
5661 return false;
5662 }
5663
5665 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5666 constexpr
5667 static BlockLength minimalBlockLength(SchemaVersion version)
5668 noexcept
5669 {
5670 return
5671 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5672 (version >= 17)
5673 ? 40
5674 : 36;
5675 }
5676
5678 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5679 constexpr
5680 static
5681 BlockLength
5682 blockLength(SchemaVersion version)
5683 noexcept
5684 {
5685 return
5686 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5687 minimalBlockLength(version);
5688 }
5689
5691 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5692 ONIXS_B3_UMDF_MD_NODISCARD
5693 constexpr
5694 static
5695 MessageSize
5696 getMinimalVariableFieldsSize(
5697 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5698 {
5699 return
5700 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5701 0;
5702 }
5703
5705 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5706 ONIXS_B3_UMDF_MD_NODISCARD
5707 constexpr
5708 static StrRef className()
5709 noexcept
5710 {
5711 return constructStrRef("SettlementPrice_28");
5712 }
5713
5715 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5716 ONIXS_B3_UMDF_MD_NODISCARD
5717 constexpr
5718 static StrRef fixType()
5719 noexcept
5720 {
5721 return constructStrRef("SettlementPrice_28");
5722 }
5723
5725 ONIXS_B3_UMDF_MD_NODISCARD
5726 std::string toString() const;
5727
5728private:
5729 void checkLength(
5730 EncodedLength length, SchemaVersion version) const
5731 {
5732 const EncodedLength minimalRequiredLength =
5733 minimalBlockLength(version) +
5734 MessageHeader::Size +
5735 getMinimalVariableFieldsSize(version);
5736
5737 checkBinaryLength(
5738 *this, length, minimalRequiredLength);
5739 }
5740
5741 void checkCompatibility() const
5742 {
5743 assert(TemplateId == templateId());
5744
5745 checkSchema<Schema>(schemaId(), version());
5746 checkLength(bufferSize(), version());
5747 }
5748};
5749
5751ONIXS_B3_UMDF_MD_LTWT_STRUCT
5752OpenInterest_29
5753: SbeMessage
5754{
5756 typedef SchemaTraits Schema;
5757
5759 enum { TemplateId = 29 };
5760
5762 OpenInterest_29() = default;
5763
5765 OpenInterest_29(
5766 void* data,
5767 EncodedLength length,
5768 NoInit)
5769 : SbeMessage(data, length)
5770 {
5771 checkCompatibility();
5772 }
5773
5775 explicit
5776 OpenInterest_29(
5777 const SbeMessage& message)
5778 : SbeMessage(message)
5779 {
5780 assert(message.valid());
5781
5782 checkCompatibility();
5783 }
5784
5787 OpenInterest_29(
5788 void* data,
5789 EncodedLength length,
5790 NoInit,
5791 NoCheck)
5792 noexcept
5793 : SbeMessage(data, length, NoCheck())
5794 {
5795 assert(schemaId() == Schema::Id);
5796 assert(version() >= Schema::MinimalVersion);
5797 assert(TemplateId == templateId());
5798 }
5799
5801 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5802 constexpr
5803 static MessageType::Enum messageType()
5804 noexcept
5805 {
5806 return MessageType::MarketDataIncrementalRefresh;
5807 }
5808
5811 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5812 constexpr
5813 static ApplVerID::Enum applVerId()
5814 noexcept
5815 {
5816 return ApplVerID::FIX50SP2;
5817 }
5818
5821 ONIXS_B3_UMDF_MD_NODISCARD
5822 SecurityID securityId() const
5823 noexcept
5824 {
5825 constexpr BlockLength offset = 0;
5826
5827 return ordinary<SecurityID>(offset);
5828 }
5829
5831 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5832 constexpr
5833 static SecurityIDSource::Enum securityIdSource()
5834 noexcept
5835 {
5836 return SecurityIDSource::EXCHANGE_SYMBOL;
5837 }
5838
5840 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5841 ONIXS_B3_UMDF_MD_NODISCARD
5842 constexpr
5843 static StrRef securityExchange()
5844 noexcept
5845 {
5846 return constructStrRef("BVMF");
5847 }
5848
5851 ONIXS_B3_UMDF_MD_NODISCARD
5852 MatchEventIndicator matchEventIndicator() const
5853 noexcept
5854 {
5855 constexpr BlockLength offset = 8;
5856
5857 return ordinary<MatchEventIndicator>(offset);
5858 }
5859
5861 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5862 constexpr
5863 static UpdateAction::Enum mDUpdateAction()
5864 noexcept
5865 {
5866 return UpdateAction::NEW;
5867 }
5868
5870 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5871 constexpr
5872 static EntryType::Enum mDEntryType()
5873 noexcept
5874 {
5875 return EntryType::OPEN_INTEREST;
5876 }
5877
5880 ONIXS_B3_UMDF_MD_NODISCARD
5881 Timestamp tradeDate() const
5882 noexcept
5883 {
5884 constexpr BlockLength offset = 10;
5885
5886 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
5887 }
5888
5890 ONIXS_B3_UMDF_MD_NODISCARD
5891 Quantity mDEntrySize() const
5892 noexcept
5893 {
5894 constexpr BlockLength offset = 12;
5895
5896 return ordinary<Quantity>(offset);
5897 }
5898
5900 ONIXS_B3_UMDF_MD_NODISCARD
5901 bool mDEntryTimestamp(UTCTimestampNanos& value) const
5902 noexcept
5903 {
5904 constexpr BlockLength offset = 20;
5905
5906 return ordinary(value, offset, NullUTCTimestampNanos());
5907 }
5908
5911 ONIXS_B3_UMDF_MD_NODISCARD
5912 bool rptSeq(RptSeq& value) const
5913 noexcept
5914 {
5915 constexpr BlockLength offset = 28;
5916
5917 return ordinary(value, offset, NullRptSeq());
5918 }
5919
5921 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5922 constexpr
5923 static
5924 BlockLength
5925 minimalBlockLength(
5926 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5927 noexcept
5928 {
5929 return
5930 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5931 32;
5932 }
5933
5935 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5936 constexpr
5937 static
5938 BlockLength
5939 blockLength(
5940 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5941 noexcept
5942 {
5943 return
5944 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5945 32;
5946 }
5947
5949 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5950 ONIXS_B3_UMDF_MD_NODISCARD
5951 constexpr
5952 static
5953 MessageSize
5954 getMinimalVariableFieldsSize(
5955 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
5956 {
5957 return
5958 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
5959 0;
5960 }
5961
5963 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5964 ONIXS_B3_UMDF_MD_NODISCARD
5965 constexpr
5966 static StrRef className()
5967 noexcept
5968 {
5969 return constructStrRef("OpenInterest_29");
5970 }
5971
5973 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
5974 ONIXS_B3_UMDF_MD_NODISCARD
5975 constexpr
5976 static StrRef fixType()
5977 noexcept
5978 {
5979 return constructStrRef("OpenInterest_29");
5980 }
5981
5983 ONIXS_B3_UMDF_MD_NODISCARD
5984 std::string toString() const;
5985
5986private:
5987 void checkLength(
5988 EncodedLength length, SchemaVersion version) const
5989 {
5990 const EncodedLength minimalRequiredLength =
5991 minimalBlockLength(version) +
5992 MessageHeader::Size +
5993 getMinimalVariableFieldsSize(version);
5994
5995 checkBinaryLength(
5996 *this, length, minimalRequiredLength);
5997 }
5998
5999 void checkCompatibility() const
6000 {
6001 assert(TemplateId == templateId());
6002
6003 checkSchema<Schema>(schemaId(), version());
6004 checkLength(bufferSize(), version());
6005 }
6006};
6007
6009ONIXS_B3_UMDF_MD_LTWT_STRUCT
6010SnapshotFullRefresh_Header_30
6011: SbeMessage
6012{
6014 typedef SchemaTraits Schema;
6015
6017 enum { TemplateId = 30 };
6018
6020 SnapshotFullRefresh_Header_30() = default;
6021
6023 SnapshotFullRefresh_Header_30(
6024 void* data,
6025 EncodedLength length,
6026 NoInit)
6027 : SbeMessage(data, length)
6028 {
6029 checkCompatibility();
6030 }
6031
6033 explicit
6034 SnapshotFullRefresh_Header_30(
6035 const SbeMessage& message)
6036 : SbeMessage(message)
6037 {
6038 assert(message.valid());
6039
6040 checkCompatibility();
6041 }
6042
6045 SnapshotFullRefresh_Header_30(
6046 void* data,
6047 EncodedLength length,
6048 NoInit,
6049 NoCheck)
6050 noexcept
6051 : SbeMessage(data, length, NoCheck())
6052 {
6053 assert(schemaId() == Schema::Id);
6054 assert(version() >= Schema::MinimalVersion);
6055 assert(TemplateId == templateId());
6056 }
6057
6059 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6060 constexpr
6061 static MessageType::Enum messageType()
6062 noexcept
6063 {
6064 return MessageType::MarketDataSnapshotFullRefresh;
6065 }
6066
6069 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6070 constexpr
6071 static ApplVerID::Enum applVerId()
6072 noexcept
6073 {
6074 return ApplVerID::FIX50SP2;
6075 }
6076
6079 ONIXS_B3_UMDF_MD_NODISCARD
6080 SecurityID securityId() const
6081 noexcept
6082 {
6083 constexpr BlockLength offset = 0;
6084
6085 return ordinary<SecurityID>(offset);
6086 }
6087
6089 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6090 constexpr
6091 static SecurityIDSource::Enum securityIdSource()
6092 noexcept
6093 {
6094 return SecurityIDSource::EXCHANGE_SYMBOL;
6095 }
6096
6098 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6099 ONIXS_B3_UMDF_MD_NODISCARD
6100 constexpr
6101 static StrRef securityExchange()
6102 noexcept
6103 {
6104 return constructStrRef("BVMF");
6105 }
6106
6111 ONIXS_B3_UMDF_MD_NODISCARD
6112 SeqNum lastMsgSeqNumProcessed() const
6113 noexcept
6114 {
6115 constexpr BlockLength offset = 8;
6116
6117 return ordinary<SeqNum>(offset);
6118 }
6119
6122 ONIXS_B3_UMDF_MD_NODISCARD
6123 UInt32 totNumReports() const
6124 noexcept
6125 {
6126 constexpr BlockLength offset = 12;
6127
6128 return ordinary<UInt32>(offset);
6129 }
6130
6132 ONIXS_B3_UMDF_MD_NODISCARD
6133 UInt32 totNumBids() const
6134 noexcept
6135 {
6136 constexpr BlockLength offset = 16;
6137
6138 return ordinary<UInt32>(offset);
6139 }
6140
6142 ONIXS_B3_UMDF_MD_NODISCARD
6143 UInt32 totNumOffers() const
6144 noexcept
6145 {
6146 constexpr BlockLength offset = 20;
6147
6148 return ordinary<UInt32>(offset);
6149 }
6150
6153 ONIXS_B3_UMDF_MD_NODISCARD
6154 UInt16 totNumStats() const
6155 noexcept
6156 {
6157 constexpr BlockLength offset = 24;
6158
6159 return ordinary<UInt16>(offset);
6160 }
6161
6166 ONIXS_B3_UMDF_MD_NODISCARD
6167 bool lastRptSeq(RptSeq& value) const
6168 noexcept
6169 {
6170 constexpr BlockLength offset = 28;
6171
6172 return ordinary(value, offset, NullRptSeq());
6173 }
6174
6179 ONIXS_B3_UMDF_MD_NODISCARD
6180 bool lastSequenceVersion(UInt16NULL& value) const
6181 noexcept
6182 {
6183 constexpr BlockLength offset = 32;
6184
6185 return ordinary(value, offset, NullUInt16NULL());
6186 }
6187
6189 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6190 constexpr
6191 static
6192 BlockLength
6193 minimalBlockLength(
6194 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6195 noexcept
6196 {
6197 return
6198 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6199 34;
6200 }
6201
6203 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6204 constexpr
6205 static
6206 BlockLength
6207 blockLength(
6208 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6209 noexcept
6210 {
6211 return
6212 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6213 minimalBlockLength(version);
6214 }
6215
6217 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6218 ONIXS_B3_UMDF_MD_NODISCARD
6219 constexpr
6220 static
6221 MessageSize
6222 getMinimalVariableFieldsSize(
6223 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6224 {
6225 return
6226 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6227 0;
6228 }
6229
6231 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6232 ONIXS_B3_UMDF_MD_NODISCARD
6233 constexpr
6234 static StrRef className()
6235 noexcept
6236 {
6237 return constructStrRef("SnapshotFullRefresh_Header_30");
6238 }
6239
6241 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6242 ONIXS_B3_UMDF_MD_NODISCARD
6243 constexpr
6244 static StrRef fixType()
6245 noexcept
6246 {
6247 return constructStrRef(
6248 "SnapshotFullRefresh_Header_30");
6249 }
6250
6252 ONIXS_B3_UMDF_MD_NODISCARD
6253 std::string toString() const;
6254
6255private:
6256 void checkLength(
6257 EncodedLength length, SchemaVersion version) const
6258 {
6259 const EncodedLength minimalRequiredLength =
6260 minimalBlockLength(version) +
6261 MessageHeader::Size +
6262 getMinimalVariableFieldsSize(version);
6263
6264 checkBinaryLength(
6265 *this, length, minimalRequiredLength);
6266 }
6267
6268 void checkCompatibility() const
6269 {
6270 assert(TemplateId == templateId());
6271
6272 checkSchema<Schema>(schemaId(), version());
6273 checkLength(bufferSize(), version());
6274 }
6275};
6276
6278ONIXS_B3_UMDF_MD_LTWT_STRUCT
6279Order_MBO_50
6280: SbeMessage
6281{
6283 typedef SchemaTraits Schema;
6284
6286 enum { TemplateId = 50 };
6287
6289 Order_MBO_50() = default;
6290
6292 Order_MBO_50(
6293 void* data,
6294 EncodedLength length,
6295 NoInit)
6296 : SbeMessage(data, length)
6297 {
6298 checkCompatibility();
6299 }
6300
6302 explicit
6303 Order_MBO_50(
6304 const SbeMessage& message)
6305 : SbeMessage(message)
6306 {
6307 assert(message.valid());
6308
6309 checkCompatibility();
6310 }
6311
6314 Order_MBO_50(
6315 void* data,
6316 EncodedLength length,
6317 NoInit,
6318 NoCheck)
6319 noexcept
6320 : SbeMessage(data, length, NoCheck())
6321 {
6322 assert(schemaId() == Schema::Id);
6323 assert(version() >= Schema::MinimalVersion);
6324 assert(TemplateId == templateId());
6325 }
6326
6328 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6329 constexpr
6330 static MessageType::Enum messageType()
6331 noexcept
6332 {
6333 return MessageType::MarketDataIncrementalRefresh;
6334 }
6335
6338 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6339 constexpr
6340 static ApplVerID::Enum applVerId()
6341 noexcept
6342 {
6343 return ApplVerID::FIX50SP2;
6344 }
6345
6348 ONIXS_B3_UMDF_MD_NODISCARD
6349 SecurityID securityId() const
6350 noexcept
6351 {
6352 constexpr BlockLength offset = 0;
6353
6354 return ordinary<SecurityID>(offset);
6355 }
6356
6358 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6359 constexpr
6360 static SecurityIDSource::Enum securityIdSource()
6361 noexcept
6362 {
6363 return SecurityIDSource::EXCHANGE_SYMBOL;
6364 }
6365
6367 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6368 ONIXS_B3_UMDF_MD_NODISCARD
6369 constexpr
6370 static StrRef securityExchange()
6371 noexcept
6372 {
6373 return constructStrRef("BVMF");
6374 }
6375
6379 ONIXS_B3_UMDF_MD_NODISCARD
6380 MatchEventIndicator matchEventIndicator() const
6381 noexcept
6382 {
6383 constexpr BlockLength offset = 8;
6384
6385 return ordinary<MatchEventIndicator>(offset);
6386 }
6387
6389 ONIXS_B3_UMDF_MD_NODISCARD
6390 UpdateAction::Enum mDUpdateAction() const
6391 noexcept
6392 {
6393 constexpr BlockLength offset = 9;
6394
6395 return enumeration<UpdateAction>(offset);
6396 }
6397
6399 ONIXS_B3_UMDF_MD_NODISCARD
6400 EntryType::Enum mDEntryType() const
6401 noexcept
6402 {
6403 constexpr BlockLength offset = 10;
6404
6405 return enumeration<EntryType>(offset);
6406 }
6407
6410 ONIXS_B3_UMDF_MD_NODISCARD
6411 bool mDEntryPx(PriceOptional& value) const
6412 noexcept
6413 {
6414 constexpr BlockLength offset = 12;
6415
6416 return decimal(value, offset, NullPriceOptional());
6417 }
6418
6421 ONIXS_B3_UMDF_MD_NODISCARD
6422 Quantity mDEntrySize() const
6423 noexcept
6424 {
6425 constexpr BlockLength offset = 20;
6426
6427 return ordinary<Quantity>(offset);
6428 }
6429
6431 ONIXS_B3_UMDF_MD_NODISCARD
6432 bool enteringFirm(FirmOptional& value) const
6433 noexcept
6434 {
6435 constexpr BlockLength offset = 32;
6436
6437 return ordinary(value, offset, NullFirmOptional());
6438 }
6439
6443 ONIXS_B3_UMDF_MD_NODISCARD
6444 bool mDInsertTimestamp(UTCTimestampNanos& value) const
6445 noexcept
6446 {
6447 constexpr BlockLength offset = 36;
6448
6449 return ordinary(value, offset, NullUTCTimestampNanos());
6450 }
6451
6459 ONIXS_B3_UMDF_MD_NODISCARD
6460 OrderID secondaryOrderId() const
6461 noexcept
6462 {
6463 constexpr BlockLength offset = 44;
6464
6465 return ordinary<OrderID>(offset);
6466 }
6467
6470 ONIXS_B3_UMDF_MD_NODISCARD
6471 bool rptSeq(RptSeq& value) const
6472 noexcept
6473 {
6474 constexpr BlockLength offset = 52;
6475
6476 return ordinary(value, offset, NullRptSeq());
6477 }
6478
6480 ONIXS_B3_UMDF_MD_NODISCARD
6481 bool transactTime(UTCTimestampNanos& value) const
6482 noexcept
6483 {
6484 constexpr BlockLength offset = 56;
6485
6486 return ordinary(value, offset, NullUTCTimestampNanos());
6487 }
6488
6494 ONIXS_B3_UMDF_MD_NODISCARD
6495 bool mDEntryPrevSize(QuantityOptional& value) const
6496 noexcept
6497 {
6498 constexpr BlockLength offset = 64;
6499 constexpr SchemaVersion since = 16;
6500
6501 return ordinary(value, offset, NullQuantityOptional(), since);
6502 }
6503
6505 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6506 constexpr
6507 static BlockLength minimalBlockLength(SchemaVersion version)
6508 noexcept
6509 {
6510 return
6511 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6512 (version >= 16)
6513 ? 72
6514 : 64;
6515 }
6516
6518 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6519 constexpr
6520 static
6521 BlockLength
6522 blockLength(
6523 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6524 noexcept
6525 {
6526 return
6527 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6528 minimalBlockLength(version);
6529 }
6530
6532 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6533 ONIXS_B3_UMDF_MD_NODISCARD
6534 constexpr
6535 static
6536 MessageSize
6537 getMinimalVariableFieldsSize(
6538 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6539 {
6540 return
6541 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6542 0;
6543 }
6544
6546 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6547 ONIXS_B3_UMDF_MD_NODISCARD
6548 constexpr
6549 static StrRef className()
6550 noexcept
6551 {
6552 return constructStrRef("Order_MBO_50");
6553 }
6554
6556 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6557 ONIXS_B3_UMDF_MD_NODISCARD
6558 constexpr
6559 static StrRef fixType()
6560 noexcept
6561 {
6562 return constructStrRef("Order_MBO_50");
6563 }
6564
6566 ONIXS_B3_UMDF_MD_NODISCARD
6567 std::string toString() const;
6568
6569private:
6570 void checkLength(
6571 EncodedLength length, SchemaVersion version) const
6572 {
6573 const EncodedLength minimalRequiredLength =
6574 minimalBlockLength(version) +
6575 MessageHeader::Size +
6576 getMinimalVariableFieldsSize(version);
6577
6578 checkBinaryLength(
6579 *this, length, minimalRequiredLength);
6580 }
6581
6582 void checkCompatibility() const
6583 {
6584 assert(TemplateId == templateId());
6585
6586 checkSchema<Schema>(schemaId(), version());
6587 checkLength(bufferSize(), version());
6588 }
6589};
6590
6592ONIXS_B3_UMDF_MD_LTWT_STRUCT
6593DeleteOrder_MBO_51
6594: SbeMessage
6595{
6597 typedef SchemaTraits Schema;
6598
6600 enum { TemplateId = 51 };
6601
6603 DeleteOrder_MBO_51() = default;
6604
6606 DeleteOrder_MBO_51(
6607 void* data,
6608 EncodedLength length,
6609 NoInit)
6610 : SbeMessage(data, length)
6611 {
6612 checkCompatibility();
6613 }
6614
6616 explicit
6617 DeleteOrder_MBO_51(
6618 const SbeMessage& message)
6619 : SbeMessage(message)
6620 {
6621 assert(message.valid());
6622
6623 checkCompatibility();
6624 }
6625
6628 DeleteOrder_MBO_51(
6629 void* data,
6630 EncodedLength length,
6631 NoInit,
6632 NoCheck)
6633 noexcept
6634 : SbeMessage(data, length, NoCheck())
6635 {
6636 assert(schemaId() == Schema::Id);
6637 assert(version() >= Schema::MinimalVersion);
6638 assert(TemplateId == templateId());
6639 }
6640
6642 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6643 constexpr
6644 static MessageType::Enum messageType()
6645 noexcept
6646 {
6647 return MessageType::MarketDataIncrementalRefresh;
6648 }
6649
6652 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6653 constexpr
6654 static ApplVerID::Enum applVerId()
6655 noexcept
6656 {
6657 return ApplVerID::FIX50SP2;
6658 }
6659
6662 ONIXS_B3_UMDF_MD_NODISCARD
6663 SecurityID securityId() const
6664 noexcept
6665 {
6666 constexpr BlockLength offset = 0;
6667
6668 return ordinary<SecurityID>(offset);
6669 }
6670
6672 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6673 constexpr
6674 static SecurityIDSource::Enum securityIdSource()
6675 noexcept
6676 {
6677 return SecurityIDSource::EXCHANGE_SYMBOL;
6678 }
6679
6681 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6682 ONIXS_B3_UMDF_MD_NODISCARD
6683 constexpr
6684 static StrRef securityExchange()
6685 noexcept
6686 {
6687 return constructStrRef("BVMF");
6688 }
6689
6692 ONIXS_B3_UMDF_MD_NODISCARD
6693 MatchEventIndicator matchEventIndicator() const
6694 noexcept
6695 {
6696 constexpr BlockLength offset = 8;
6697
6698 return ordinary<MatchEventIndicator>(offset);
6699 }
6700
6702 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6703 constexpr
6704 static UpdateAction::Enum mDUpdateAction()
6705 noexcept
6706 {
6707 return UpdateAction::DELETE;
6708 }
6709
6711 ONIXS_B3_UMDF_MD_NODISCARD
6712 EntryType::Enum mDEntryType() const
6713 noexcept
6714 {
6715 constexpr BlockLength offset = 10;
6716
6717 return enumeration<EntryType>(offset);
6718 }
6719
6721 ONIXS_B3_UMDF_MD_NODISCARD
6722 Quantity mDEntrySize() const
6723 noexcept
6724 {
6725 constexpr BlockLength offset = 16;
6726
6727 return ordinary<Quantity>(offset);
6728 }
6729
6735 ONIXS_B3_UMDF_MD_NODISCARD
6736 OrderID secondaryOrderId() const
6737 noexcept
6738 {
6739 constexpr BlockLength offset = 24;
6740
6741 return ordinary<OrderID>(offset);
6742 }
6743
6745 ONIXS_B3_UMDF_MD_NODISCARD
6746 bool transactTime(UTCTimestampNanos& value) const
6747 noexcept
6748 {
6749 constexpr BlockLength offset = 32;
6750
6751 return ordinary(value, offset, NullUTCTimestampNanos());
6752 }
6753
6756 ONIXS_B3_UMDF_MD_NODISCARD
6757 bool rptSeq(RptSeq& value) const
6758 noexcept
6759 {
6760 constexpr BlockLength offset = 40;
6761
6762 return ordinary(value, offset, NullRptSeq());
6763 }
6764
6766 ONIXS_B3_UMDF_MD_NODISCARD
6767 bool mDEntryPx(PriceOptional& value) const
6768 noexcept
6769 {
6770 constexpr BlockLength offset = 44;
6771
6772 return decimal(value, offset, NullPriceOptional());
6773 }
6774
6776 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6777 constexpr
6778 static
6779 BlockLength
6780 minimalBlockLength(
6781 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6782 noexcept
6783 {
6784 return
6785 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6786 52;
6787 }
6788
6790 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6791 constexpr
6792 static
6793 BlockLength
6794 blockLength(
6795 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6796 noexcept
6797 {
6798 return
6799 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6800 minimalBlockLength(version);
6801 }
6802
6804 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6805 ONIXS_B3_UMDF_MD_NODISCARD
6806 constexpr
6807 static
6808 MessageSize
6809 getMinimalVariableFieldsSize(
6810 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
6811 {
6812 return
6813 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
6814 0;
6815 }
6816
6818 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6819 ONIXS_B3_UMDF_MD_NODISCARD
6820 constexpr
6821 static StrRef className()
6822 noexcept
6823 {
6824 return constructStrRef("DeleteOrder_MBO_51");
6825 }
6826
6828 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6829 ONIXS_B3_UMDF_MD_NODISCARD
6830 constexpr
6831 static StrRef fixType()
6832 noexcept
6833 {
6834 return constructStrRef("DeleteOrder_MBO_51");
6835 }
6836
6838 ONIXS_B3_UMDF_MD_NODISCARD
6839 std::string toString() const;
6840
6841private:
6842 void checkLength(
6843 EncodedLength length, SchemaVersion version) const
6844 {
6845 const EncodedLength minimalRequiredLength =
6846 minimalBlockLength(version) +
6847 MessageHeader::Size +
6848 getMinimalVariableFieldsSize(version);
6849
6850 checkBinaryLength(
6851 *this, length, minimalRequiredLength);
6852 }
6853
6854 void checkCompatibility() const
6855 {
6856 assert(TemplateId == templateId());
6857
6858 checkSchema<Schema>(schemaId(), version());
6859 checkLength(bufferSize(), version());
6860 }
6861};
6862
6864ONIXS_B3_UMDF_MD_LTWT_STRUCT
6865MassDeleteOrders_MBO_52
6866: SbeMessage
6867{
6869 typedef SchemaTraits Schema;
6870
6872 enum { TemplateId = 52 };
6873
6875 MassDeleteOrders_MBO_52() = default;
6876
6878 MassDeleteOrders_MBO_52(
6879 void* data,
6880 EncodedLength length,
6881 NoInit)
6882 : SbeMessage(data, length)
6883 {
6884 checkCompatibility();
6885 }
6886
6888 explicit
6889 MassDeleteOrders_MBO_52(
6890 const SbeMessage& message)
6891 : SbeMessage(message)
6892 {
6893 assert(message.valid());
6894
6895 checkCompatibility();
6896 }
6897
6900 MassDeleteOrders_MBO_52(
6901 void* data,
6902 EncodedLength length,
6903 NoInit,
6904 NoCheck)
6905 noexcept
6906 : SbeMessage(data, length, NoCheck())
6907 {
6908 assert(schemaId() == Schema::Id);
6909 assert(version() >= Schema::MinimalVersion);
6910 assert(TemplateId == templateId());
6911 }
6912
6914 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6915 constexpr
6916 static MessageType::Enum messageType()
6917 noexcept
6918 {
6919 return MessageType::MarketDataIncrementalRefresh;
6920 }
6921
6924 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6925 constexpr
6926 static ApplVerID::Enum applVerId()
6927 noexcept
6928 {
6929 return ApplVerID::FIX50SP2;
6930 }
6931
6934 ONIXS_B3_UMDF_MD_NODISCARD
6935 SecurityID securityId() const
6936 noexcept
6937 {
6938 constexpr BlockLength offset = 0;
6939
6940 return ordinary<SecurityID>(offset);
6941 }
6942
6944 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6945 constexpr
6946 static SecurityIDSource::Enum securityIdSource()
6947 noexcept
6948 {
6949 return SecurityIDSource::EXCHANGE_SYMBOL;
6950 }
6951
6953 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
6954 ONIXS_B3_UMDF_MD_NODISCARD
6955 constexpr
6956 static StrRef securityExchange()
6957 noexcept
6958 {
6959 return constructStrRef("BVMF");
6960 }
6961
6964 ONIXS_B3_UMDF_MD_NODISCARD
6965 MatchEventIndicator matchEventIndicator() const
6966 noexcept
6967 {
6968 constexpr BlockLength offset = 8;
6969
6970 return ordinary<MatchEventIndicator>(offset);
6971 }
6972
6974 ONIXS_B3_UMDF_MD_NODISCARD
6975 UpdateAction::Enum mDUpdateAction() const
6976 noexcept
6977 {
6978 constexpr BlockLength offset = 9;
6979
6980 return enumeration<UpdateAction>(offset);
6981 }
6982
6984 ONIXS_B3_UMDF_MD_NODISCARD
6985 EntryType::Enum mDEntryType() const
6986 noexcept
6987 {
6988 constexpr BlockLength offset = 10;
6989
6990 return enumeration<EntryType>(offset);
6991 }
6992
6994 ONIXS_B3_UMDF_MD_NODISCARD
6995 bool transactTime(UTCTimestampNanos& value) const
6996 noexcept
6997 {
6998 constexpr BlockLength offset = 16;
6999
7000 return ordinary(value, offset, NullUTCTimestampNanos());
7001 }
7002
7005 ONIXS_B3_UMDF_MD_NODISCARD
7006 bool rptSeq(RptSeq& value) const
7007 noexcept
7008 {
7009 constexpr BlockLength offset = 24;
7010
7011 return ordinary(value, offset, NullRptSeq());
7012 }
7013
7015 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7016 constexpr
7017 static
7018 BlockLength
7019 minimalBlockLength(
7020 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7021 noexcept
7022 {
7023 return
7024 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7025 28;
7026 }
7027
7029 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7030 constexpr
7031 static
7032 BlockLength
7033 blockLength(
7034 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7035 noexcept
7036 {
7037 return
7038 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7039 minimalBlockLength(version);
7040 }
7041
7043 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7044 ONIXS_B3_UMDF_MD_NODISCARD
7045 constexpr
7046 static
7047 MessageSize
7048 getMinimalVariableFieldsSize(
7049 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7050 {
7051 return
7052 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7053 0;
7054 }
7055
7057 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7058 ONIXS_B3_UMDF_MD_NODISCARD
7059 constexpr
7060 static StrRef className()
7061 noexcept
7062 {
7063 return constructStrRef("MassDeleteOrders_MBO_52");
7064 }
7065
7067 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7068 ONIXS_B3_UMDF_MD_NODISCARD
7069 constexpr
7070 static StrRef fixType()
7071 noexcept
7072 {
7073 return constructStrRef(
7074 "MassDeleteOrders_MBO_52");
7075 }
7076
7078 ONIXS_B3_UMDF_MD_NODISCARD
7079 std::string toString() const;
7080
7081private:
7082 void checkLength(
7083 EncodedLength length, SchemaVersion version) const
7084 {
7085 const EncodedLength minimalRequiredLength =
7086 minimalBlockLength(version) +
7087 MessageHeader::Size +
7088 getMinimalVariableFieldsSize(version);
7089
7090 checkBinaryLength(
7091 *this, length, minimalRequiredLength);
7092 }
7093
7094 void checkCompatibility() const
7095 {
7096 assert(TemplateId == templateId());
7097
7098 checkSchema<Schema>(schemaId(), version());
7099 checkLength(bufferSize(), version());
7100 }
7101};
7102
7104ONIXS_B3_UMDF_MD_LTWT_STRUCT
7105Trade_53
7106: SbeMessage
7107{
7109 typedef SchemaTraits Schema;
7110
7112 enum { TemplateId = 53 };
7113
7115 Trade_53() = default;
7116
7118 Trade_53(
7119 void* data,
7120 EncodedLength length,
7121 NoInit)
7122 : SbeMessage(data, length)
7123 {
7124 checkCompatibility();
7125 }
7126
7128 explicit
7129 Trade_53(
7130 const SbeMessage& message)
7131 : SbeMessage(message)
7132 {
7133 assert(message.valid());
7134
7135 checkCompatibility();
7136 }
7137
7140 Trade_53(
7141 void* data,
7142 EncodedLength length,
7143 NoInit,
7144 NoCheck)
7145 noexcept
7146 : SbeMessage(data, length, NoCheck())
7147 {
7148 assert(schemaId() == Schema::Id);
7149 assert(version() >= Schema::MinimalVersion);
7150 assert(TemplateId == templateId());
7151 }
7152
7154 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7155 constexpr
7156 static MessageType::Enum messageType()
7157 noexcept
7158 {
7159 return MessageType::MarketDataIncrementalRefresh;
7160 }
7161
7164 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7165 constexpr
7166 static ApplVerID::Enum applVerId()
7167 noexcept
7168 {
7169 return ApplVerID::FIX50SP2;
7170 }
7171
7174 ONIXS_B3_UMDF_MD_NODISCARD
7175 SecurityID securityId() const
7176 noexcept
7177 {
7178 constexpr BlockLength offset = 0;
7179
7180 return ordinary<SecurityID>(offset);
7181 }
7182
7184 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7185 constexpr
7186 static SecurityIDSource::Enum securityIdSource()
7187 noexcept
7188 {
7189 return SecurityIDSource::EXCHANGE_SYMBOL;
7190 }
7191
7193 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7194 ONIXS_B3_UMDF_MD_NODISCARD
7195 constexpr
7196 static StrRef securityExchange()
7197 noexcept
7198 {
7199 return constructStrRef("BVMF");
7200 }
7201
7204 ONIXS_B3_UMDF_MD_NODISCARD
7205 MatchEventIndicator matchEventIndicator() const
7206 noexcept
7207 {
7208 constexpr BlockLength offset = 8;
7209
7210 return ordinary<MatchEventIndicator>(offset);
7211 }
7212
7214 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7215 constexpr
7216 static UpdateAction::Enum mDUpdateAction()
7217 noexcept
7218 {
7219 return UpdateAction::NEW;
7220 }
7221
7223 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7224 constexpr
7225 static EntryType::Enum mDEntryType()
7226 noexcept
7227 {
7228 return EntryType::TRADE;
7229 }
7230
7232 ONIXS_B3_UMDF_MD_NODISCARD
7233 TradingSessionID::Enum tradingSessionId() const
7234 noexcept
7235 {
7236 constexpr BlockLength offset = 9;
7237
7238 return enumeration<TradingSessionID>(offset);
7239 }
7240
7242 ONIXS_B3_UMDF_MD_NODISCARD
7243 TradeCondition tradeCondition() const
7244 noexcept
7245 {
7246 constexpr BlockLength offset = 10;
7247
7248 return ordinary<TradeCondition>(offset);
7249 }
7250
7252 ONIXS_B3_UMDF_MD_NODISCARD
7253 Price mDEntryPx() const
7254 noexcept
7255 {
7256 constexpr BlockLength offset = 12;
7257
7258 return decimal<Price>(offset);
7259 }
7260
7262 ONIXS_B3_UMDF_MD_NODISCARD
7263 Quantity mDEntrySize() const
7264 noexcept
7265 {
7266 constexpr BlockLength offset = 20;
7267
7268 return ordinary<Quantity>(offset);
7269 }
7270
7274 ONIXS_B3_UMDF_MD_NODISCARD
7275 TradeID tradeId() const
7276 noexcept
7277 {
7278 constexpr BlockLength offset = 28;
7279
7280 return ordinary<TradeID>(offset);
7281 }
7282
7284 ONIXS_B3_UMDF_MD_NODISCARD
7285 bool mDEntryBuyer(FirmOptional& value) const
7286 noexcept
7287 {
7288 constexpr BlockLength offset = 32;
7289
7290 return ordinary(value, offset, NullFirmOptional());
7291 }
7292
7294 ONIXS_B3_UMDF_MD_NODISCARD
7295 bool mDEntrySeller(FirmOptional& value) const
7296 noexcept
7297 {
7298 constexpr BlockLength offset = 36;
7299
7300 return ordinary(value, offset, NullFirmOptional());
7301 }
7302
7305 ONIXS_B3_UMDF_MD_NODISCARD
7306 Timestamp tradeDate() const
7307 noexcept
7308 {
7309 constexpr BlockLength offset = 40;
7310
7311 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
7312 }
7313
7315 ONIXS_B3_UMDF_MD_NODISCARD
7316 bool trdSubType(TrdSubType::Enum& value) const
7317 noexcept
7318 {
7319 constexpr BlockLength offset = 42;
7320
7321 return enumeration<TrdSubType>(value, offset, NullUInt8NULL());
7322 }
7323
7326 ONIXS_B3_UMDF_MD_NODISCARD
7327 bool transactTime(UTCTimestampNanos& value) const
7328 noexcept
7329 {
7330 constexpr BlockLength offset = 44;
7331
7332 return ordinary(value, offset, NullUTCTimestampNanos());
7333 }
7334
7337 ONIXS_B3_UMDF_MD_NODISCARD
7338 bool rptSeq(RptSeq& value) const
7339 noexcept
7340 {
7341 constexpr BlockLength offset = 52;
7342
7343 return ordinary(value, offset, NullRptSeq());
7344 }
7345
7347 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7348 constexpr
7349 static
7350 BlockLength
7351 minimalBlockLength(
7352 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7353 noexcept
7354 {
7355 return
7356 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7357 56;
7358 }
7359
7361 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7362 constexpr
7363 static
7364 BlockLength
7365 blockLength(
7366 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7367 noexcept
7368 {
7369 return
7370 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7371 minimalBlockLength(version);
7372 }
7373
7375 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7376 ONIXS_B3_UMDF_MD_NODISCARD
7377 constexpr
7378 static
7379 MessageSize
7380 getMinimalVariableFieldsSize(
7381 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7382 {
7383 return
7384 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7385 0;
7386 }
7387
7389 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7390 ONIXS_B3_UMDF_MD_NODISCARD
7391 constexpr
7392 static StrRef className()
7393 noexcept
7394 {
7395 return constructStrRef("Trade_53");
7396 }
7397
7399 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7400 ONIXS_B3_UMDF_MD_NODISCARD
7401 constexpr
7402 static StrRef fixType()
7403 noexcept
7404 {
7405 return constructStrRef("Trade_53");
7406 }
7407
7409 ONIXS_B3_UMDF_MD_NODISCARD
7410 std::string toString() const;
7411
7412private:
7413 void checkLength(
7414 EncodedLength length, SchemaVersion version) const
7415 {
7416 const EncodedLength minimalRequiredLength =
7417 minimalBlockLength(version) +
7418 MessageHeader::Size +
7419 getMinimalVariableFieldsSize(version);
7420
7421 checkBinaryLength(
7422 *this, length, minimalRequiredLength);
7423 }
7424
7425 void checkCompatibility() const
7426 {
7427 assert(TemplateId == templateId());
7428
7429 checkSchema<Schema>(schemaId(), version());
7430 checkLength(bufferSize(), version());
7431 }
7432};
7433
7435ONIXS_B3_UMDF_MD_LTWT_STRUCT
7436ForwardTrade_54
7437: SbeMessage
7438{
7440 typedef SchemaTraits Schema;
7441
7443 enum { TemplateId = 54 };
7444
7446 ForwardTrade_54() = default;
7447
7449 ForwardTrade_54(
7450 void* data,
7451 EncodedLength length,
7452 NoInit)
7453 : SbeMessage(data, length)
7454 {
7455 checkCompatibility();
7456 }
7457
7459 explicit
7460 ForwardTrade_54(
7461 const SbeMessage& message)
7462 : SbeMessage(message)
7463 {
7464 assert(message.valid());
7465
7466 checkCompatibility();
7467 }
7468
7471 ForwardTrade_54(
7472 void* data,
7473 EncodedLength length,
7474 NoInit,
7475 NoCheck)
7476 noexcept
7477 : SbeMessage(data, length, NoCheck())
7478 {
7479 assert(schemaId() == Schema::Id);
7480 assert(version() >= Schema::MinimalVersion);
7481 assert(TemplateId == templateId());
7482 }
7483
7485 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7486 constexpr
7487 static MessageType::Enum messageType()
7488 noexcept
7489 {
7490 return MessageType::MarketDataIncrementalRefresh;
7491 }
7492
7495 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7496 constexpr
7497 static ApplVerID::Enum applVerId()
7498 noexcept
7499 {
7500 return ApplVerID::FIX50SP2;
7501 }
7502
7505 ONIXS_B3_UMDF_MD_NODISCARD
7506 SecurityID securityId() const
7507 noexcept
7508 {
7509 constexpr BlockLength offset = 0;
7510
7511 return ordinary<SecurityID>(offset);
7512 }
7513
7515 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7516 constexpr
7517 static SecurityIDSource::Enum securityIdSource()
7518 noexcept
7519 {
7520 return SecurityIDSource::EXCHANGE_SYMBOL;
7521 }
7522
7524 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7525 ONIXS_B3_UMDF_MD_NODISCARD
7526 constexpr
7527 static StrRef securityExchange()
7528 noexcept
7529 {
7530 return constructStrRef("BVMF");
7531 }
7532
7535 ONIXS_B3_UMDF_MD_NODISCARD
7536 MatchEventIndicator matchEventIndicator() const
7537 noexcept
7538 {
7539 constexpr BlockLength offset = 8;
7540
7541 return ordinary<MatchEventIndicator>(offset);
7542 }
7543
7545 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7546 constexpr
7547 static UpdateAction::Enum mDUpdateAction()
7548 noexcept
7549 {
7550 return UpdateAction::NEW;
7551 }
7552
7554 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7555 constexpr
7556 static EntryType::Enum mDEntryType()
7557 noexcept
7558 {
7559 return EntryType::TRADE;
7560 }
7561
7563 ONIXS_B3_UMDF_MD_NODISCARD
7564 TradingSessionID::Enum tradingSessionId() const
7565 noexcept
7566 {
7567 constexpr BlockLength offset = 9;
7568
7569 return enumeration<TradingSessionID>(offset);
7570 }
7571
7573 ONIXS_B3_UMDF_MD_NODISCARD
7574 TradeCondition tradeCondition() const
7575 noexcept
7576 {
7577 constexpr BlockLength offset = 10;
7578
7579 return ordinary<TradeCondition>(offset);
7580 }
7581
7583 ONIXS_B3_UMDF_MD_NODISCARD
7584 Price mDEntryPx() const
7585 noexcept
7586 {
7587 constexpr BlockLength offset = 12;
7588
7589 return decimal<Price>(offset);
7590 }
7591
7593 ONIXS_B3_UMDF_MD_NODISCARD
7594 Quantity mDEntrySize() const
7595 noexcept
7596 {
7597 constexpr BlockLength offset = 20;
7598
7599 return ordinary<Quantity>(offset);
7600 }
7601
7605 ONIXS_B3_UMDF_MD_NODISCARD
7606 TradeID tradeId() const
7607 noexcept
7608 {
7609 constexpr BlockLength offset = 28;
7610
7611 return ordinary<TradeID>(offset);
7612 }
7613
7615 ONIXS_B3_UMDF_MD_NODISCARD
7616 bool mDEntryBuyer(FirmOptional& value) const
7617 noexcept
7618 {
7619 constexpr BlockLength offset = 32;
7620
7621 return ordinary(value, offset, NullFirmOptional());
7622 }
7623
7625 ONIXS_B3_UMDF_MD_NODISCARD
7626 bool mDEntrySeller(FirmOptional& value) const
7627 noexcept
7628 {
7629 constexpr BlockLength offset = 36;
7630
7631 return ordinary(value, offset, NullFirmOptional());
7632 }
7633
7636 ONIXS_B3_UMDF_MD_NODISCARD
7637 Timestamp tradeDate() const
7638 noexcept
7639 {
7640 constexpr BlockLength offset = 40;
7641
7642 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
7643 }
7644
7647 ONIXS_B3_UMDF_MD_NODISCARD
7648 bool transactTime(UTCTimestampNanos& value) const
7649 noexcept
7650 {
7651 constexpr BlockLength offset = 42;
7652
7653 return ordinary(value, offset, NullUTCTimestampNanos());
7654 }
7655
7658 ONIXS_B3_UMDF_MD_NODISCARD
7659 bool rptSeq(RptSeq& value) const
7660 noexcept
7661 {
7662 constexpr BlockLength offset = 50;
7663
7664 return ordinary(value, offset, NullRptSeq());
7665 }
7666
7670 ONIXS_B3_UMDF_MD_NODISCARD
7671 bool sellerDays(UInt16NULL& value) const
7672 noexcept
7673 {
7674 constexpr BlockLength offset = 54;
7675
7676 return ordinary(value, offset, NullUInt16NULL());
7677 }
7678
7682 ONIXS_B3_UMDF_MD_NODISCARD
7683 bool mDEntryInterestRate(Percentage& value) const
7684 noexcept
7685 {
7686 constexpr BlockLength offset = 56;
7687
7688 return decimal(value, offset, NullPercentage());
7689 }
7690
7692 ONIXS_B3_UMDF_MD_NODISCARD
7693 bool trdSubType(TrdSubType::Enum& value) const
7694 noexcept
7695 {
7696 constexpr BlockLength offset = 64;
7697
7698 return enumeration<TrdSubType>(value, offset, NullUInt8NULL());
7699 }
7700
7702 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7703 constexpr
7704 static
7705 BlockLength
7706 minimalBlockLength(
7707 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7708 noexcept
7709 {
7710 return
7711 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7712 68;
7713 }
7714
7716 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7717 constexpr
7718 static
7719 BlockLength
7720 blockLength(
7721 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7722 noexcept
7723 {
7724 return
7725 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7726 68;
7727 }
7728
7730 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7731 ONIXS_B3_UMDF_MD_NODISCARD
7732 constexpr
7733 static
7734 MessageSize
7735 getMinimalVariableFieldsSize(
7736 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7737 {
7738 return
7739 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
7740 0;
7741 }
7742
7744 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7745 ONIXS_B3_UMDF_MD_NODISCARD
7746 constexpr
7747 static StrRef className()
7748 noexcept
7749 {
7750 return constructStrRef("ForwardTrade_54");
7751 }
7752
7754 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7755 ONIXS_B3_UMDF_MD_NODISCARD
7756 constexpr
7757 static StrRef fixType()
7758 noexcept
7759 {
7760 return constructStrRef("ForwardTrade_54");
7761 }
7762
7764 ONIXS_B3_UMDF_MD_NODISCARD
7765 std::string toString() const;
7766
7767private:
7768 void checkLength(
7769 EncodedLength length, SchemaVersion version) const
7770 {
7771 const EncodedLength minimalRequiredLength =
7772 minimalBlockLength(version) +
7773 MessageHeader::Size +
7774 getMinimalVariableFieldsSize(version);
7775
7776 checkBinaryLength(
7777 *this, length, minimalRequiredLength);
7778 }
7779
7780 void checkCompatibility() const
7781 {
7782 assert(TemplateId == templateId());
7783
7784 checkSchema<Schema>(schemaId(), version());
7785 checkLength(bufferSize(), version());
7786 }
7787};
7788
7790ONIXS_B3_UMDF_MD_LTWT_STRUCT
7791ExecutionSummary_55
7792: SbeMessage
7793{
7795 typedef SchemaTraits Schema;
7796
7798 enum { TemplateId = 55 };
7799
7801 ExecutionSummary_55() = default;
7802
7804 ExecutionSummary_55(
7805 void* data,
7806 EncodedLength length,
7807 NoInit)
7808 : SbeMessage(data, length)
7809 {
7810 checkCompatibility();
7811 }
7812
7814 explicit
7815 ExecutionSummary_55(
7816 const SbeMessage& message)
7817 : SbeMessage(message)
7818 {
7819 assert(message.valid());
7820
7821 checkCompatibility();
7822 }
7823
7826 ExecutionSummary_55(
7827 void* data,
7828 EncodedLength length,
7829 NoInit,
7830 NoCheck)
7831 noexcept
7832 : SbeMessage(data, length, NoCheck())
7833 {
7834 assert(schemaId() == Schema::Id);
7835 assert(version() >= Schema::MinimalVersion);
7836 assert(TemplateId == templateId());
7837 }
7838
7840 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7841 constexpr
7842 static MessageType::Enum messageType()
7843 noexcept
7844 {
7845 return MessageType::MarketDataIncrementalRefresh;
7846 }
7847
7850 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7851 constexpr
7852 static ApplVerID::Enum applVerId()
7853 noexcept
7854 {
7855 return ApplVerID::FIX50SP2;
7856 }
7857
7860 ONIXS_B3_UMDF_MD_NODISCARD
7861 SecurityID securityId() const
7862 noexcept
7863 {
7864 constexpr BlockLength offset = 0;
7865
7866 return ordinary<SecurityID>(offset);
7867 }
7868
7870 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7871 constexpr
7872 static SecurityIDSource::Enum securityIdSource()
7873 noexcept
7874 {
7875 return SecurityIDSource::EXCHANGE_SYMBOL;
7876 }
7877
7879 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7880 ONIXS_B3_UMDF_MD_NODISCARD
7881 constexpr
7882 static StrRef securityExchange()
7883 noexcept
7884 {
7885 return constructStrRef("BVMF");
7886 }
7887
7889 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7890 constexpr
7891 static UpdateAction::Enum mDUpdateAction()
7892 noexcept
7893 {
7894 return UpdateAction::NEW;
7895 }
7896
7898 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7899 constexpr
7900 static EntryType::Enum mDEntryType()
7901 noexcept
7902 {
7903 return EntryType::EXECUTION_SUMMARY;
7904 }
7905
7907 ONIXS_B3_UMDF_MD_NODISCARD
7908 AggressorSide::Enum aggressorSide() const
7909 noexcept
7910 {
7911 constexpr BlockLength offset = 10;
7912
7913 return enumeration<AggressorSide>(offset);
7914 }
7915
7917 ONIXS_B3_UMDF_MD_NODISCARD
7918 Price lastPx() const
7919 noexcept
7920 {
7921 constexpr BlockLength offset = 12;
7922
7923 return decimal<Price>(offset);
7924 }
7925
7927 ONIXS_B3_UMDF_MD_NODISCARD
7928 Quantity fillQty() const
7929 noexcept
7930 {
7931 constexpr BlockLength offset = 20;
7932
7933 return ordinary<Quantity>(offset);
7934 }
7935
7938 ONIXS_B3_UMDF_MD_NODISCARD
7939 bool tradedHiddenQty(QuantityOptional& value) const
7940 noexcept
7941 {
7942 constexpr BlockLength offset = 28;
7943
7944 return ordinary(value, offset, NullQuantityOptional());
7945 }
7946
7949 ONIXS_B3_UMDF_MD_NODISCARD
7950 bool cxlQty(QuantityOptional& value) const
7951 noexcept
7952 {
7953 constexpr BlockLength offset = 36;
7954
7955 return ordinary(value, offset, NullQuantityOptional());
7956 }
7957
7959 ONIXS_B3_UMDF_MD_NODISCARD
7960 bool aggressorTime(UTCTimestampNanos& value) const
7961 noexcept
7962 {
7963 constexpr BlockLength offset = 44;
7964
7965 return ordinary(value, offset, NullUTCTimestampNanos());
7966 }
7967
7970 ONIXS_B3_UMDF_MD_NODISCARD
7971 bool rptSeq(RptSeq& value) const
7972 noexcept
7973 {
7974 constexpr BlockLength offset = 52;
7975
7976 return ordinary(value, offset, NullRptSeq());
7977 }
7978
7981 ONIXS_B3_UMDF_MD_NODISCARD
7982 bool transactTime(UTCTimestampNanos& value) const
7983 noexcept
7984 {
7985 constexpr BlockLength offset = 56;
7986
7987 return ordinary(value, offset, NullUTCTimestampNanos());
7988 }
7989
7991 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
7992 constexpr
7993 static
7994 BlockLength
7995 minimalBlockLength(
7996 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
7997 noexcept
7998 {
7999 return
8000 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8001 64;
8002 }
8003
8005 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8006 constexpr
8007 static
8008 BlockLength
8009 blockLength(
8010 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8011 noexcept
8012 {
8013 return
8014 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8015 minimalBlockLength(version);
8016 }
8017
8019 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8020 ONIXS_B3_UMDF_MD_NODISCARD
8021 constexpr
8022 static
8023 MessageSize
8024 getMinimalVariableFieldsSize(
8025 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8026 {
8027 return
8028 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8029 0;
8030 }
8031
8033 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8034 ONIXS_B3_UMDF_MD_NODISCARD
8035 constexpr
8036 static StrRef className()
8037 noexcept
8038 {
8039 return constructStrRef("ExecutionSummary_55");
8040 }
8041
8043 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8044 ONIXS_B3_UMDF_MD_NODISCARD
8045 constexpr
8046 static StrRef fixType()
8047 noexcept
8048 {
8049 return constructStrRef("ExecutionSummary_55");
8050 }
8051
8053 ONIXS_B3_UMDF_MD_NODISCARD
8054 std::string toString() const;
8055
8056private:
8057 void checkLength(
8058 EncodedLength length, SchemaVersion version) const
8059 {
8060 const EncodedLength minimalRequiredLength =
8061 minimalBlockLength(version) +
8062 MessageHeader::Size +
8063 getMinimalVariableFieldsSize(version);
8064
8065 checkBinaryLength(
8066 *this, length, minimalRequiredLength);
8067 }
8068
8069 void checkCompatibility() const
8070 {
8071 assert(TemplateId == templateId());
8072
8073 checkSchema<Schema>(schemaId(), version());
8074 checkLength(bufferSize(), version());
8075 }
8076};
8077
8079ONIXS_B3_UMDF_MD_LTWT_STRUCT
8080ExecutionStatistics_56
8081: SbeMessage
8082{
8084 typedef SchemaTraits Schema;
8085
8087 enum { TemplateId = 56 };
8088
8090 ExecutionStatistics_56() = default;
8091
8093 ExecutionStatistics_56(
8094 void* data,
8095 EncodedLength length,
8096 NoInit)
8097 : SbeMessage(data, length)
8098 {
8099 checkCompatibility();
8100 }
8101
8103 explicit
8104 ExecutionStatistics_56(
8105 const SbeMessage& message)
8106 : SbeMessage(message)
8107 {
8108 assert(message.valid());
8109
8110 checkCompatibility();
8111 }
8112
8115 ExecutionStatistics_56(
8116 void* data,
8117 EncodedLength length,
8118 NoInit,
8119 NoCheck)
8120 noexcept
8121 : SbeMessage(data, length, NoCheck())
8122 {
8123 assert(schemaId() == Schema::Id);
8124 assert(version() >= Schema::MinimalVersion);
8125 assert(TemplateId == templateId());
8126 }
8127
8129 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8130 constexpr
8131 static MessageType::Enum messageType()
8132 noexcept
8133 {
8134 return MessageType::MarketDataIncrementalRefresh;
8135 }
8136
8139 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8140 constexpr
8141 static ApplVerID::Enum applVerId()
8142 noexcept
8143 {
8144 return ApplVerID::FIX50SP2;
8145 }
8146
8149 ONIXS_B3_UMDF_MD_NODISCARD
8150 SecurityID securityId() const
8151 noexcept
8152 {
8153 constexpr BlockLength offset = 0;
8154
8155 return ordinary<SecurityID>(offset);
8156 }
8157
8159 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8160 constexpr
8161 static SecurityIDSource::Enum securityIdSource()
8162 noexcept
8163 {
8164 return SecurityIDSource::EXCHANGE_SYMBOL;
8165 }
8166
8168 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8169 ONIXS_B3_UMDF_MD_NODISCARD
8170 constexpr
8171 static StrRef securityExchange()
8172 noexcept
8173 {
8174 return constructStrRef("BVMF");
8175 }
8176
8179 ONIXS_B3_UMDF_MD_NODISCARD
8180 MatchEventIndicator matchEventIndicator() const
8181 noexcept
8182 {
8183 constexpr BlockLength offset = 8;
8184
8185 return ordinary<MatchEventIndicator>(offset);
8186 }
8187
8189 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8190 constexpr
8191 static UpdateAction::Enum mDUpdateAction()
8192 noexcept
8193 {
8194 return UpdateAction::NEW;
8195 }
8196
8198 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8199 constexpr
8200 static EntryType::Enum mDEntryType()
8201 noexcept
8202 {
8203 return EntryType::EXECUTION_STATISTICS;
8204 }
8205
8207 ONIXS_B3_UMDF_MD_NODISCARD
8208 TradingSessionID::Enum tradingSessionId() const
8209 noexcept
8210 {
8211 constexpr BlockLength offset = 9;
8212
8213 return enumeration<TradingSessionID>(offset);
8214 }
8215
8218 ONIXS_B3_UMDF_MD_NODISCARD
8219 Timestamp tradeDate() const
8220 noexcept
8221 {
8222 constexpr BlockLength offset = 10;
8223
8224 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
8225 }
8226
8228 ONIXS_B3_UMDF_MD_NODISCARD
8229 QuantityVolume tradeVolume() const
8230 noexcept
8231 {
8232 constexpr BlockLength offset = 12;
8233
8234 return ordinary<QuantityVolume>(offset);
8235 }
8236
8238 ONIXS_B3_UMDF_MD_NODISCARD
8239 bool vwapPx(PriceOptional& value) const
8240 noexcept
8241 {
8242 constexpr BlockLength offset = 20;
8243
8244 return decimal(value, offset, NullPriceOptional());
8245 }
8246
8249 ONIXS_B3_UMDF_MD_NODISCARD
8250 bool
8251 netChgPrevDay(
8252 PriceOffset8Optional& value) const
8253 noexcept
8254 {
8255 constexpr BlockLength offset = 28;
8256
8257 return decimal(value, offset, NullPriceOffset8Optional());
8258 }
8259
8261 ONIXS_B3_UMDF_MD_NODISCARD
8262 NumberOfTrades numberOfTrades() const
8263 noexcept
8264 {
8265 constexpr BlockLength offset = 36;
8266
8267 return ordinary<NumberOfTrades>(offset);
8268 }
8269
8271 ONIXS_B3_UMDF_MD_NODISCARD
8272 bool mDEntryTimestamp(UTCTimestampNanos& value) const
8273 noexcept
8274 {
8275 constexpr BlockLength offset = 40;
8276
8277 return ordinary(value, offset, NullUTCTimestampNanos());
8278 }
8279
8282 ONIXS_B3_UMDF_MD_NODISCARD
8283 bool rptSeq(RptSeq& value) const
8284 noexcept
8285 {
8286 constexpr BlockLength offset = 48;
8287
8288 return ordinary(value, offset, NullRptSeq());
8289 }
8290
8292 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8293 constexpr
8294 static
8295 BlockLength
8296 minimalBlockLength(
8297 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8298 noexcept
8299 {
8300 return
8301 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8302 52;
8303 }
8304
8306 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8307 constexpr
8308 static BlockLength blockLength(SchemaVersion version)
8309 noexcept
8310 {
8311 return
8312 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8313 minimalBlockLength(version);
8314 }
8315
8317 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8318 ONIXS_B3_UMDF_MD_NODISCARD
8319 constexpr
8320 static
8321 MessageSize
8322 getMinimalVariableFieldsSize(
8323 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8324 {
8325 return
8326 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8327 0;
8328 }
8329
8331 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8332 ONIXS_B3_UMDF_MD_NODISCARD
8333 constexpr
8334 static StrRef className()
8335 noexcept
8336 {
8337 return constructStrRef("ExecutionStatistics_56");
8338 }
8339
8341 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8342 ONIXS_B3_UMDF_MD_NODISCARD
8343 constexpr
8344 static StrRef fixType()
8345 noexcept
8346 {
8347 return constructStrRef("ExecutionStatistics_56");
8348 }
8349
8351 ONIXS_B3_UMDF_MD_NODISCARD
8352 std::string toString() const;
8353
8354private:
8355 void checkLength(
8356 EncodedLength length, SchemaVersion version) const
8357 {
8358 const EncodedLength minimalRequiredLength =
8359 minimalBlockLength(version) +
8360 MessageHeader::Size +
8361 getMinimalVariableFieldsSize(version);
8362
8363 checkBinaryLength(
8364 *this, length, minimalRequiredLength);
8365 }
8366
8367 void checkCompatibility() const
8368 {
8369 assert(TemplateId == templateId());
8370
8371 checkSchema<Schema>(schemaId(), version());
8372 checkLength(bufferSize(), version());
8373 }
8374};
8375
8377ONIXS_B3_UMDF_MD_LTWT_STRUCT
8378TradeBust_57
8379: SbeMessage
8380{
8382 typedef SchemaTraits Schema;
8383
8385 enum { TemplateId = 57 };
8386
8388 TradeBust_57() = default;
8389
8391 TradeBust_57(
8392 void* data,
8393 EncodedLength length,
8394 NoInit)
8395 : SbeMessage(data, length)
8396 {
8397 checkCompatibility();
8398 }
8399
8401 explicit
8402 TradeBust_57(
8403 const SbeMessage& message)
8404 : SbeMessage(message)
8405 {
8406 assert(message.valid());
8407
8408 checkCompatibility();
8409 }
8410
8413 TradeBust_57(
8414 void* data,
8415 EncodedLength length,
8416 NoInit,
8417 NoCheck)
8418 noexcept
8419 : SbeMessage(data, length, NoCheck())
8420 {
8421 assert(schemaId() == Schema::Id);
8422 assert(version() >= Schema::MinimalVersion);
8423 assert(TemplateId == templateId());
8424 }
8425
8427 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8428 constexpr
8429 static MessageType::Enum messageType()
8430 noexcept
8431 {
8432 return MessageType::MarketDataIncrementalRefresh;
8433 }
8434
8437 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8438 constexpr
8439 static ApplVerID::Enum applVerId()
8440 noexcept
8441 {
8442 return ApplVerID::FIX50SP2;
8443 }
8444
8447 ONIXS_B3_UMDF_MD_NODISCARD
8448 SecurityID securityId() const
8449 noexcept
8450 {
8451 constexpr BlockLength offset = 0;
8452
8453 return ordinary<SecurityID>(offset);
8454 }
8455
8457 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8458 constexpr
8459 static SecurityIDSource::Enum securityIdSource()
8460 noexcept
8461 {
8462 return SecurityIDSource::EXCHANGE_SYMBOL;
8463 }
8464
8466 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8467 ONIXS_B3_UMDF_MD_NODISCARD
8468 constexpr
8469 static StrRef securityExchange()
8470 noexcept
8471 {
8472 return constructStrRef("BVMF");
8473 }
8474
8477 ONIXS_B3_UMDF_MD_NODISCARD
8478 MatchEventIndicator matchEventIndicator() const
8479 noexcept
8480 {
8481 constexpr BlockLength offset = 8;
8482
8483 return ordinary<MatchEventIndicator>(offset);
8484 }
8485
8487 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8488 constexpr
8489 static UpdateAction::Enum mDUpdateAction()
8490 noexcept
8491 {
8492 return UpdateAction::DELETE;
8493 }
8494
8496 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8497 constexpr
8498 static EntryType::Enum mDEntryType()
8499 noexcept
8500 {
8501 return EntryType::TRADE_BUST;
8502 }
8503
8505 ONIXS_B3_UMDF_MD_NODISCARD
8506 TradingSessionID::Enum tradingSessionId() const
8507 noexcept
8508 {
8509 constexpr BlockLength offset = 9;
8510
8511 return enumeration<TradingSessionID>(offset);
8512 }
8513
8515 ONIXS_B3_UMDF_MD_NODISCARD
8516 Price mDEntryPx() const
8517 noexcept
8518 {
8519 constexpr BlockLength offset = 12;
8520
8521 return decimal<Price>(offset);
8522 }
8523
8525 ONIXS_B3_UMDF_MD_NODISCARD
8526 Quantity mDEntrySize() const
8527 noexcept
8528 {
8529 constexpr BlockLength offset = 20;
8530
8531 return ordinary<Quantity>(offset);
8532 }
8533
8537 ONIXS_B3_UMDF_MD_NODISCARD
8538 TradeID tradeId() const
8539 noexcept
8540 {
8541 constexpr BlockLength offset = 28;
8542
8543 return ordinary<TradeID>(offset);
8544 }
8545
8548 ONIXS_B3_UMDF_MD_NODISCARD
8549 Timestamp tradeDate() const
8550 noexcept
8551 {
8552 constexpr BlockLength offset = 32;
8553
8554 return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
8555 }
8556
8558 ONIXS_B3_UMDF_MD_NODISCARD
8559 bool transactTime(UTCTimestampNanos& value) const
8560 noexcept
8561 {
8562 constexpr BlockLength offset = 36;
8563
8564 return ordinary(value, offset, NullUTCTimestampNanos());
8565 }
8566
8569 ONIXS_B3_UMDF_MD_NODISCARD
8570 bool rptSeq(RptSeq& value) const
8571 noexcept
8572 {
8573 constexpr BlockLength offset = 44;
8574
8575 return ordinary(value, offset, NullRptSeq());
8576 }
8577
8579 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8580 constexpr
8581 static
8582 BlockLength
8583 minimalBlockLength(
8584 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8585 noexcept
8586 {
8587 return
8588 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8589 48;
8590 }
8591
8593 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8594 constexpr
8595 static
8596 BlockLength
8597 blockLength(
8598 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8599 noexcept
8600 {
8601 return
8602 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8603 minimalBlockLength(version);
8604 }
8605
8607 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8608 ONIXS_B3_UMDF_MD_NODISCARD
8609 constexpr
8610 static
8611 MessageSize
8612 getMinimalVariableFieldsSize(
8613 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8614 {
8615 return
8616 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8617 0;
8618 }
8619
8621 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8622 ONIXS_B3_UMDF_MD_NODISCARD
8623 constexpr
8624 static StrRef className()
8625 noexcept
8626 {
8627 return constructStrRef("TradeBust_57");
8628 }
8629
8631 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8632 ONIXS_B3_UMDF_MD_NODISCARD
8633 constexpr
8634 static StrRef fixType()
8635 noexcept
8636 {
8637 return constructStrRef("TradeBust_57");
8638 }
8639
8641 ONIXS_B3_UMDF_MD_NODISCARD
8642 std::string toString() const;
8643
8644private:
8645 void checkLength(
8646 EncodedLength length, SchemaVersion version) const
8647 {
8648 const EncodedLength minimalRequiredLength =
8649 minimalBlockLength(version) +
8650 MessageHeader::Size +
8651 getMinimalVariableFieldsSize(version);
8652
8653 checkBinaryLength(
8654 *this, length, minimalRequiredLength);
8655 }
8656
8657 void checkCompatibility() const
8658 {
8659 assert(TemplateId == templateId());
8660
8661 checkSchema<Schema>(schemaId(), version());
8662 checkLength(bufferSize(), version());
8663 }
8664};
8665
8667ONIXS_B3_UMDF_MD_LTWT_STRUCT
8668SnapshotFullRefresh_Orders_MBO_71
8669: SbeMessage
8670{
8672 typedef SchemaTraits Schema;
8673
8675 enum { TemplateId = 71 };
8676
8679 ONIXS_B3_UMDF_MD_LTWT_STRUCT
8680 Entry : SbeGroupEntry
8681 <
8682 GroupSizeEncoding::BlockLength
8683 >
8684 {
8686 typedef
8687 SbeGroupEntry
8688 <
8689 GroupSizeEncoding::BlockLength
8690 >
8691 Base;
8692
8695 Entry(
8696 const void* data,
8697 EncodedLength length,
8698 SchemaVersion version)
8699 : Base(data, numericCast<Base::BlockLength>(length), version)
8700 {
8701 assert(version >= Schema::MinimalVersion);
8702 assert(length >= minimalBlockLength(version));
8703 }
8704
8707 ONIXS_B3_UMDF_MD_NODISCARD
8708 bool mDEntryPx(PriceOptional& value) const
8709 noexcept
8710 {
8711 constexpr BlockLength offset = 0;
8712
8713 return decimal(value, offset, NullPriceOptional());
8714 }
8715
8718 ONIXS_B3_UMDF_MD_NODISCARD
8719 Quantity mDEntrySize() const
8720 noexcept
8721 {
8722 constexpr BlockLength offset = 8;
8723
8724 return ordinary<Quantity>(offset);
8725 }
8726
8728 ONIXS_B3_UMDF_MD_NODISCARD
8729 bool enteringFirm(FirmOptional& value) const
8730 noexcept
8731 {
8732 constexpr BlockLength offset = 20;
8733
8734 return ordinary(value, offset, NullFirmOptional());
8735 }
8736
8740 ONIXS_B3_UMDF_MD_NODISCARD
8741 bool mDInsertTimestamp(UTCTimestampNanos& value) const
8742 noexcept
8743 {
8744 constexpr BlockLength offset = 24;
8745
8746 return ordinary(value, offset, NullUTCTimestampNanos());
8747 }
8748
8756 ONIXS_B3_UMDF_MD_NODISCARD
8757 OrderID secondaryOrderId() const
8758 noexcept
8759 {
8760 constexpr BlockLength offset = 32;
8761
8762 return ordinary<OrderID>(offset);
8763 }
8764
8766 ONIXS_B3_UMDF_MD_NODISCARD
8767 EntryType::Enum mDEntryType() const
8768 noexcept
8769 {
8770 constexpr BlockLength offset = 40;
8771
8772 return enumeration<EntryType>(offset);
8773 }
8774
8777 ONIXS_B3_UMDF_MD_NODISCARD
8778 MatchEventIndicator matchEventIndicator() const
8779 noexcept
8780 {
8781 constexpr BlockLength offset = 41;
8782
8783 return ordinary<MatchEventIndicator>(offset);
8784 }
8785
8788 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8789 constexpr
8790 static
8791 BlockLength
8792 blockLength(
8793 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8794 noexcept
8795 {
8796 return
8797 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8798 42;
8799 }
8800
8803 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8804 constexpr
8805 static
8806 BlockLength
8807 minimalBlockLength(
8808 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8809 noexcept
8810 {
8811 return
8812 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8813 42;
8814 }
8815
8817 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8818 ONIXS_B3_UMDF_MD_NODISCARD
8819 constexpr
8820 static StrRef className()
8821 noexcept
8822 {
8823 return constructStrRef("SnapshotFullRefresh_Orders_MBO_71.Entry");
8824 }
8825 };
8826
8828 typedef
8829 SbeGroup<Entry, GroupSizeEncoding, MessageSize>
8830 Entries;
8831
8833 SnapshotFullRefresh_Orders_MBO_71() = default;
8834
8836 SnapshotFullRefresh_Orders_MBO_71(
8837 void* data,
8838 EncodedLength length,
8839 NoInit)
8840 : SbeMessage(data, length)
8841 {
8842 checkCompatibility();
8843 }
8844
8846 explicit
8847 SnapshotFullRefresh_Orders_MBO_71(
8848 const SbeMessage& message)
8849 : SbeMessage(message)
8850 {
8851 assert(message.valid());
8852
8853 checkCompatibility();
8854 }
8855
8858 SnapshotFullRefresh_Orders_MBO_71(
8859 void* data,
8860 EncodedLength length,
8861 NoInit,
8862 NoCheck)
8863 noexcept
8864 : SbeMessage(data, length, NoCheck())
8865 {
8866 assert(schemaId() == Schema::Id);
8867 assert(version() >= Schema::MinimalVersion);
8868 assert(TemplateId == templateId());
8869 }
8870
8872 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8873 constexpr
8874 static MessageType::Enum messageType()
8875 noexcept
8876 {
8877 return MessageType::MarketDataSnapshotFullRefresh;
8878 }
8879
8882 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8883 constexpr
8884 static ApplVerID::Enum applVerId()
8885 noexcept
8886 {
8887 return ApplVerID::FIX50SP2;
8888 }
8889
8892 ONIXS_B3_UMDF_MD_NODISCARD
8893 SecurityID securityId() const
8894 noexcept
8895 {
8896 constexpr BlockLength offset = 0;
8897
8898 return ordinary<SecurityID>(offset);
8899 }
8900
8902 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8903 constexpr
8904 static SecurityIDSource::Enum securityIdSource()
8905 noexcept
8906 {
8907 return SecurityIDSource::EXCHANGE_SYMBOL;
8908 }
8909
8911 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8912 ONIXS_B3_UMDF_MD_NODISCARD
8913 constexpr
8914 static StrRef securityExchange()
8915 noexcept
8916 {
8917 return constructStrRef("BVMF");
8918 }
8919
8921 ONIXS_B3_UMDF_MD_NODISCARD
8922 Entries entries() const
8923 noexcept
8924 {
8925 return getGroup<Entries>(EntriesAccess(), *this);
8926 }
8927
8929 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8930 constexpr
8931 static
8932 BlockLength
8933 minimalBlockLength(
8934 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8935 noexcept
8936 {
8937 return
8938 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8939 8;
8940 }
8941
8943 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8944 constexpr
8945 static BlockLength blockLength(SchemaVersion version)
8946 noexcept
8947 {
8948 return
8949 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8950 minimalBlockLength(version);
8951 }
8952
8954 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8955 ONIXS_B3_UMDF_MD_NODISCARD
8956 constexpr
8957 static
8958 MessageSize
8959 getMinimalVariableFieldsSize(
8960 ONIXS_B3_UMDF_MD_UNUSED SchemaVersion version)
8961 {
8962 return
8963 ONIXS_B3_UMDF_MD_ASSERT(version >= Schema::MinimalVersion),
8964 static_cast<MessageSize>(Entries::EmptySize);
8965 }
8966
8968 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8969 ONIXS_B3_UMDF_MD_NODISCARD
8970 constexpr
8971 static StrRef className()
8972 noexcept
8973 {
8974 return constructStrRef("SnapshotFullRefresh_Orders_MBO_71");
8975 }
8976
8978 ONIXS_B3_UMDF_MD_LTWT_EXPORTED
8979 ONIXS_B3_UMDF_MD_NODISCARD
8980 constexpr
8981 static StrRef fixType()
8982 noexcept
8983 {
8984 return constructStrRef(
8985 "SnapshotFullRefresh_Orders_MBO_71");
8986 }
8987
8989 ONIXS_B3_UMDF_MD_NODISCARD
8990 std::string toString() const;
8991
8992private:
8993 void checkLength(
8994 EncodedLength length, SchemaVersion version) const
8995 {
8996 const EncodedLength minimalRequiredLength =
8997 minimalBlockLength(version) +
8998 MessageHeader::Size +
8999 getMinimalVariableFieldsSize(version);
9000
9001 checkBinaryLength(
9002 *this, length, minimalRequiredLength);
9003 }
9004
9006 void checkVarLenFields() const
9007 {
9008 groups().
9009 checkTail<Entries>();
9010 }
9011
9012 void checkCompatibility() const
9013 {
9014 assert(TemplateId == templateId());
9015
9016 checkSchema<Schema>(schemaId(), version());
9017 checkLength(bufferSize(), version());
9018 checkVarLenFields();
9019 }
9020
9022 struct EntriesAccess
9023 {
9024 Entries
9025 operator()(
9026 const SnapshotFullRefresh_Orders_MBO_71& obj) const
9027 noexcept
9028 {
9029 return obj.
9030 groups().
9031 head<Entries>();
9032 }
9033 };
9034};
9035
9036
9037ONIXS_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_UNUSED
#define ONIXS_B3_UMDF_MD_UNUSED
Definition Compiler.h:135
ONIXS_B3_UMDF_MD_NODISCARD
#define ONIXS_B3_UMDF_MD_NODISCARD
Definition Compiler.h:131
OnixS::B3::MarketData::UMDF::Date
Represents calendar date without time-zone information.
Definition Time.h:920
OnixS::B3::MarketData::UMDF::Messaging::BinaryBlock::decimal
Value decimal(BlockLength offset) const noexcept
Definition SbeMessage.h:140
OnixS::B3::MarketData::UMDF::Messaging::MaturityMonthYear
Week, month and year of the maturity (used for standardized futures and options).
Definition Composites.h:869
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::SbeMessage::getVariableLengthField
StrRef getVariableLengthField(Callable callable, const Owner &owner) const noexcept
Definition SbeMessage.h:1456
OnixS::B3::MarketData::UMDF::Messaging::UTCTimestampNanos
UTC timestamp with nanosecond precision (Unix Epoch).
Definition Composites.h:615
OnixS::B3::MarketData::UMDF::Messaging::UTCTimestampSeconds
UTC timestamp with second precision (Unix Epoch).
Definition Composites.h:742
OnixS::B3::MarketData::UMDF::Timestamp
Represents time point without time-zone information.
Definition Time.h:483
OnixS::B3::MarketData::UMDF::Messaging::NumberOfTrades
UInt32 NumberOfTrades
Contains the number of trades executed in the session.
Definition Fields.h:104
OnixS::B3::MarketData::UMDF::Messaging::NullNewsID
IntegralConstant< UInt64, 0ULL > NullNewsID
Null value for an optional NewsID field.
Definition Fields.h:1959
OnixS::B3::MarketData::UMDF::Messaging::Percentage
FixedPointDecimal< Int64, IntegralConstant< Int8, -4 > > Percentage
Optional percentage (4 decimal places).
Definition Composites.h:237
OnixS::B3::MarketData::UMDF::Messaging::constructStrRef
constexpr StrRef constructStrRef(const char(&value)[Size]) noexcept
Definition StrRef.h:415
OnixS::B3::MarketData::UMDF::Messaging::LocalMktDate
UInt16 LocalMktDate
Local date (as opposed to UTC).
Definition Fields.h:214
OnixS::B3::MarketData::UMDF::Messaging::QuantityVolume
Int64 QuantityVolume
Volume Quantity.
Definition Fields.h:122
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:1863
OnixS::B3::MarketData::UMDF::Messaging::NullLocalMktDateOptional
IntegralConstant< UInt16, 0 > NullLocalMktDateOptional
Null value for an optional LocalMktDateOptional field.
Definition Fields.h:1977
OnixS::B3::MarketData::UMDF::Messaging::NullRptSeq
IntegralConstant< UInt32, 0 > NullRptSeq
Null value for an optional RptSeq field.
Definition Fields.h:1947
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::Fixed8
FixedPointDecimal< Int64, IntegralConstant< Int8, -8 > > Fixed8
Optional decimal with constant exponent -8.
Definition Composites.h:371
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:1941
OnixS::B3::MarketData::UMDF::Messaging::SeqNum1
IntegralConstant< UInt32, 1 > SeqNum1
Sequence Number, fixed to 1.
Definition Fields.h:162
OnixS::B3::MarketData::UMDF::Messaging::TradeID
UInt32 TradeID
Contains the unique identifier for this trade per instrument + trading date, as assigned by the excha...
Definition Fields.h:148
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:1869
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:1905
OnixS::B3::MarketData::UMDF::Messaging::NullClearingHouseID
IntegralConstant< UInt64, 0ULL > NullClearingHouseID
Null value for an optional ClearingHouseID field.
Definition Fields.h:1953
OnixS::B3::MarketData::UMDF::Messaging::SchemaVersion
MessageHeader::Version SchemaVersion
SBE-encoded data version type.
Definition SchemaTraits.h:30
OnixS::B3::MarketData::UMDF::Messaging::NullLocalMktDate
IntegralConstant< UInt16, 65535 > NullLocalMktDate
Null value for an optional LocalMktDate field.
Definition Fields.h:1971
OnixS::B3::MarketData::UMDF::Messaging::NullUInt8
IntegralConstant< UInt8, 255 > NullUInt8
Null value for an optional UInt8 field.
Definition Fields.h:1797
OnixS::B3::MarketData::UMDF::Messaging::QuantityOptional
Int64 QuantityOptional
Quantity in order/trade.
Definition Fields.h:116
OnixS::B3::MarketData::UMDF::Messaging::LocalMktDateOptional
UInt16 LocalMktDateOptional
Optional local date (as opposed to UTC).
Definition Fields.h:220
OnixS::B3::MarketData::UMDF::Messaging::MarketSegmentID
UInt8 MarketSegmentID
Identifies the market segment.
Definition Fields.h:240
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:1989
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:1887
OnixS::B3::MarketData::UMDF::Messaging::localMktDateToTimestamp
Timestamp localMktDateToTimestamp(LocalMktDate days) noexcept
Converts days since epoch to Timestamp value.
Definition Fields.h:2009
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:1851
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:1965
OnixS::B3::MarketData::UMDF::Messaging::Quantity
Int64 Quantity
Quantity in order/trade.
Definition Fields.h:110
OnixS::B3::MarketData::UMDF::Messaging::UInt32NULL
UInt32 UInt32NULL
4-byte unsigned integer, from 1 to 4294967295 (2^32-1), NULL (optional) value = 0.
Definition Fields.h:94
OnixS::B3::MarketData::UMDF::Messaging::NullQuantityVolumeOptional
IntegralConstant< Int64, -9223372036854775807LL-1 > NullQuantityVolumeOptional
Null value for an optional QuantityVolumeOptional field.
Definition Fields.h:1899
OnixS::B3::MarketData::UMDF::Messaging::PriceOffset8Optional
FixedPointDecimal< Int64, IntegralConstant< Int8, -8 > > PriceOffset8Optional
Price Offset (8 decimal places).
Definition Composites.h:450
OnixS::B3::MarketData::UMDF::Messaging::UInt64NULL
UInt64 UInt64NULL
8-byte unsigned integer, from 1 to 18446744073709551615 (2^64-1), NULL (optional) value = 0.
Definition Fields.h:98
OnixS::B3::MarketData::UMDF::Messaging::ClearingHouseID
UInt64 ClearingHouseID
ClearingHouseID (SecurityAltID).
Definition Fields.h:192
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::UInt8
UInt8 UInt8
1-byte unsigned integer, from 0 to 255.
Definition Fields.h:50
OnixS::B3::MarketData::UMDF::Messaging::NullMarketSegmentID
IntegralConstant< UInt8, 0 > NullMarketSegmentID
Null value for an optional MarketSegmentID field.
Definition Fields.h:2001
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:1857
OnixS::B3::MarketData::UMDF::Messaging::SettlType
UInt16 SettlType
Indicates order settlement period in days. (e.g. 0, D1, D2, D3, D60, D120 etc.) If present,...
Definition Fields.h:208
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::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:3920
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::imbalanceCondition
ImbalanceCondition imbalanceCondition() const noexcept
IMBALANCE_MORE_BUYERS, IMBALANCE_MORE_SELLERS, All bits off => BALANCED.
Definition Messages.h:3876
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:3797
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::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:3896
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::mDEntrySize
bool mDEntrySize(QuantityOptional &value) const noexcept
Remaining auction quantity.
Definition Messages.h:3886
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Imbalance.
Definition Messages.h:3867
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::AuctionImbalance_19
AuctionImbalance_19()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:3846
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:3750
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:3816
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:3837
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::TemplateId
@ TemplateId
Definition Messages.h:3753
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::applVerId
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::AuctionImbalance_19::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:3907
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:3946
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::className
static constexpr StrRef className() noexcept
Definition Messages.h:3958
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:3932
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::mDUpdateAction
UpdateAction::Enum mDUpdateAction() const noexcept
Update Action (NEW or DELETE).
Definition Messages.h:3856
OnixS::B3::MarketData::UMDF::Messaging::AuctionImbalance_19::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:3968
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
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:3827
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:706
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:645
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:693
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::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Type of the Market Data Entry.
Definition Messages.h:673
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:683
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:598
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::TemplateId
@ TemplateId
Definition Messages.h:601
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::applVerId
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::ChannelReset_11::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:735
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::className
static constexpr StrRef className() noexcept
Definition Messages.h:747
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:720
OnixS::B3::MarketData::UMDF::Messaging::ChannelReset_11::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:757
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::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:664
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::lastTradeDate
bool lastTradeDate(Timestamp &value) const noexcept
Date the instrument last traded.
Definition Messages.h:3607
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:3661
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:3509
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:3637
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::mDEntryPx
Price8 mDEntryPx() const noexcept
Closing price. May be adjusted by corporate events.
Definition Messages.h:3597
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::TemplateId
@ TemplateId
Definition Messages.h:3465
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Closing Price.
Definition Messages.h:3578
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:3558
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:3462
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:3528
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:3549
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::ClosingPrice_17
ClosingPrice_17()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::applVerId
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::ClosingPrice_17::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:3648
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:3690
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::className
static constexpr StrRef className() noexcept
Definition Messages.h:3702
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:3675
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::openCloseSettlFlag
OpenCloseSettlFlag::Enum openCloseSettlFlag() const noexcept
Identifies if the closing price represents a daily or entry from previous business day.
Definition Messages.h:3587
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:3712
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::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:3569
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:3627
OnixS::B3::MarketData::UMDF::Messaging::ClosingPrice_17::securityIdSource
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::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::DeleteOrder_MBO_51::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6780
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:6644
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::mDEntrySize
Quantity mDEntrySize() const noexcept
Quantity of the deleted order.
Definition Messages.h:6722
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:6693
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:6628
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:6597
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:6606
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::secondaryOrderId
OrderID secondaryOrderId() const noexcept
Exchange-generated identifier of the order that is deleted from the book.
Definition Messages.h:6736
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:6663
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:6617
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:6684
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:6654
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:6757
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:6809
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::className
static constexpr StrRef className() noexcept
Definition Messages.h:6821
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6794
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::mDEntryType
EntryType::Enum mDEntryType() const noexcept
Entry Type (BID or OFFER).
Definition Messages.h:6712
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:6831
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (DELETE).
Definition Messages.h:6704
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::TemplateId
@ TemplateId
Definition Messages.h:6600
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when the order event occurred.
Definition Messages.h:6746
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:6674
OnixS::B3::MarketData::UMDF::Messaging::DeleteOrder_MBO_51::mDEntryPx
bool mDEntryPx(PriceOptional &value) const noexcept
Price per share or contract of the deleted order.
Definition Messages.h:6767
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:509
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::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:418
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:496
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::mDEntryType
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)
Creates an instance over the given memory block.
Definition Messages.h:380
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:486
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:371
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:455
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:476
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::applVerId
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::EmptyBook_9::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:538
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::TemplateId
@ TemplateId
Definition Messages.h:374
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::className
static constexpr StrRef className() noexcept
Definition Messages.h:550
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:523
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:560
OnixS::B3::MarketData::UMDF::Messaging::EmptyBook_9::mDUpdateAction
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(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
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:466
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::tradingSessionId
TradingSessionID::Enum tradingSessionId() const noexcept
Identifier for trading session.
Definition Messages.h:8208
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:8296
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::TemplateId
@ TemplateId
Definition Messages.h:8087
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::tradeVolume
QuantityVolume tradeVolume() const noexcept
Total traded volume for the session.
Definition Messages.h:8229
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:8131
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:8272
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::ExecutionStatistics_56
ExecutionStatistics_56()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Execution Statistics.
Definition Messages.h:8200
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:8180
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:8084
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:8115
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::vwapPx
bool vwapPx(PriceOptional &value) const noexcept
Volume-weighted average price.
Definition Messages.h:8239
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:8150
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:8093
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::numberOfTrades
NumberOfTrades numberOfTrades() const noexcept
Number of trades executed in the session.
Definition Messages.h:8262
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:8171
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::netChgPrevDay
bool netChgPrevDay(PriceOffset8Optional &value) const noexcept
Net change from previous trading day’s closing price vs.
Definition Messages.h:8251
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:8141
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:8283
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:8322
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::className
static constexpr StrRef className() noexcept
Definition Messages.h:8334
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:8308
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:8344
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:8191
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:8104
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:8219
OnixS::B3::MarketData::UMDF::Messaging::ExecutionStatistics_56::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:8161
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7995
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:7842
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::fillQty
Quantity fillQty() const noexcept
Quantity of all fills.
Definition Messages.h:7928
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::aggressorSide
AggressorSide::Enum aggressorSide() const noexcept
Which side is aggressor of all fills.
Definition Messages.h:7908
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::ExecutionSummary_55
ExecutionSummary_55()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Execution Summary.
Definition Messages.h:7900
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::aggressorTime
bool aggressorTime(UTCTimestampNanos &value) const noexcept
Timestamp of aggressive order resulting in match event.
Definition Messages.h:7960
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::lastPx
Price lastPx() const noexcept
Price of the last fill (i.e. worst price of this match).
Definition Messages.h:7918
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:7795
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:7861
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::tradedHiddenQty
bool tradedHiddenQty(QuantityOptional &value) const noexcept
Total quantity of matched passive orders that is not displayed to the market.
Definition Messages.h:7939
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:7815
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:7882
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::TemplateId
@ TemplateId
Definition Messages.h:7798
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:7852
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:7971
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:8024
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:7804
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::className
static constexpr StrRef className() noexcept
Definition Messages.h:8036
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:8009
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::cxlQty
bool cxlQty(QuantityOptional &value) const noexcept
Total quantity canceled during matching process (e.g.
Definition Messages.h:7950
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:8046
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:7891
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when the last trade of the execution event occurred.
Definition Messages.h:7982
OnixS::B3::MarketData::UMDF::Messaging::ExecutionSummary_55::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:7872
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:7826
OnixS::B3::MarketData::UMDF::Messaging::ExerciseStyle::Enum
Enum
Type of exercise of a derivatives security.
Definition Fields.h:540
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::tradingSessionId
TradingSessionID::Enum tradingSessionId() const noexcept
Identifier for trading session.
Definition Messages.h:7564
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7706
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:7460
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:7487
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:7471
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:7449
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDEntrySize
Quantity mDEntrySize() const noexcept
Quantity or volume represented by the Market Data Entry.
Definition Messages.h:7594
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Trade.
Definition Messages.h:7556
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:7536
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:7440
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDEntryPx
Price mDEntryPx() const noexcept
Price of the Market Data Entry.
Definition Messages.h:7584
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDEntryBuyer
bool mDEntryBuyer(FirmOptional &value) const noexcept
For reporting trades (buying party).
Definition Messages.h:7616
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:7506
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::tradeId
TradeID tradeId() const noexcept
Contains the unique identifier for this trade per instrument + trading date, as assigned by the excha...
Definition Messages.h:7606
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:7527
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:7497
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:7659
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::TemplateId
@ TemplateId
Definition Messages.h:7443
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:7735
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDEntryInterestRate
bool mDEntryInterestRate(Percentage &value) const noexcept
Interest Rate of the Termo Trade.
Definition Messages.h:7683
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::className
static constexpr StrRef className() noexcept
Definition Messages.h:7747
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7720
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7757
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW).
Definition Messages.h:7547
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::trdSubType
bool trdSubType(TrdSubType::Enum &value) const noexcept
Sub type of trade assigned to a trade.
Definition Messages.h:7693
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:7637
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when the trade event occurred.
Definition Messages.h:7648
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:7517
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::sellerDays
bool sellerDays(UInt16NULL &value) const noexcept
Specifies the number of days that may elapse before delivery of the security.
Definition Messages.h:7671
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::tradeCondition
TradeCondition tradeCondition() const noexcept
Set of conditions describing a trade.
Definition Messages.h:7574
OnixS::B3::MarketData::UMDF::Messaging::ForwardTrade_54::mDEntrySeller
bool mDEntrySeller(FirmOptional &value) const noexcept
For reporting trades (selling party).
Definition Messages.h:7626
OnixS::B3::MarketData::UMDF::Messaging::GovernanceIndicator::Enum
Enum
Corporative governance level indicator. Required for cash equities.
Definition Fields.h:696
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4751
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:4590
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:4628
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:4727
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Trading Session High Price.
Definition Messages.h:4698
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:4677
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:4601
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:4581
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::mDEntryPx
Price mDEntryPx() const noexcept
Trading Session High Price.
Definition Messages.h:4717
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::HighPrice_24
HighPrice_24()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:4647
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:4668
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:4638
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:4738
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:4777
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::className
static constexpr StrRef className() noexcept
Definition Messages.h:4789
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4763
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::mDUpdateAction
UpdateAction::Enum mDUpdateAction() const noexcept
Update Action (NEW or DELETE).
Definition Messages.h:4687
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4799
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::TemplateId
@ TemplateId
Definition Messages.h:4584
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:4612
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:4707
OnixS::B3::MarketData::UMDF::Messaging::HighPrice_24::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:4658
OnixS::B3::MarketData::UMDF::Messaging::ImbalanceCondition
Set of conditions describing an imbalance.
Definition Fields.h:1474
OnixS::B3::MarketData::UMDF::Messaging::ImpliedMarketIndicator::Enum
Enum
Indicates that an implied order can be created for the instrument.
Definition Fields.h:1428
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:1323
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::tradingSessionId
TradingSessionID::Enum tradingSessionId() const noexcept
Identifier for trading session.
Definition Messages.h:5217
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:5358
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:5140
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:5300
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::TemplateId
@ TemplateId
Definition Messages.h:5096
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:5102
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDEntrySize
Quantity mDEntrySize() const noexcept
Quantity or volume represented by the Market Data Entry.
Definition Messages.h:5247
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Last Trade Price.
Definition Messages.h:5209
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:5189
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:5093
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDEntryPx
Price mDEntryPx() const noexcept
Last Trade Price.
Definition Messages.h:5237
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDEntryBuyer
bool mDEntryBuyer(FirmOptional &value) const noexcept
For reporting trades (buying party).
Definition Messages.h:5269
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:5159
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::tradeId
TradeID tradeId() const noexcept
Contains the unique identifier for this trade per instrument + trading date, as assigned by the excha...
Definition Messages.h:5259
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:5180
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:5150
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:5311
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:5387
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDEntryInterestRate
bool mDEntryInterestRate(Percentage &value) const noexcept
Interest Rate of the Termo Trade.
Definition Messages.h:5335
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::className
static constexpr StrRef className() noexcept
Definition Messages.h:5399
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5372
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:5113
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:5409
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:5200
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::trdSubType
bool trdSubType(TrdSubType::Enum &value) const noexcept
Sub type of trade assigned to a trade.
Definition Messages.h:5345
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:5290
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::LastTradePrice_27
LastTradePrice_27()=default
Initializes a blank instance.
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:5124
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:5170
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::sellerDays
bool sellerDays(UInt16NULL &value) const noexcept
Specifies the number of days that may elapse before delivery of the security.
Definition Messages.h:5323
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::tradeCondition
TradeCondition tradeCondition() const noexcept
Set of conditions describing a trade.
Definition Messages.h:5227
OnixS::B3::MarketData::UMDF::Messaging::LastTradePrice_27::mDEntrySeller
bool mDEntrySeller(FirmOptional &value) const noexcept
For reporting trades (selling party).
Definition Messages.h:5279
OnixS::B3::MarketData::UMDF::Messaging::LotType::Enum
Enum
Describes the lot type for the instruments. Used for the Equities segment.
Definition Fields.h:399
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:5007
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:4884
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:4983
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::LowPrice_25
LowPrice_25()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Trading Session Low Price.
Definition Messages.h:4954
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:4933
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:4837
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:4868
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::mDEntryPx
Price mDEntryPx() const noexcept
Trading Session Low Price.
Definition Messages.h:4973
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:4903
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:4846
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:4924
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:4894
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:4994
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:5033
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::className
static constexpr StrRef className() noexcept
Definition Messages.h:5045
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5019
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::mDUpdateAction
UpdateAction::Enum mDUpdateAction() const noexcept
Update Action (NEW or DELETE).
Definition Messages.h:4943
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:5055
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:4857
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:4963
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:4914
OnixS::B3::MarketData::UMDF::Messaging::LowPrice_25::TemplateId
@ TemplateId
Definition Messages.h:4840
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7019
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:6916
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:6965
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:6869
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:6935
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:6878
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::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:6956
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:6926
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:7006
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:7048
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::className
static constexpr StrRef className() noexcept
Definition Messages.h:7060
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7033
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::mDEntryType
EntryType::Enum mDEntryType() const noexcept
Entry Type (BID or OFFER).
Definition Messages.h:6985
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::mDUpdateAction
UpdateAction::Enum mDUpdateAction() const noexcept
Update Action (always DELETE_THRU).
Definition Messages.h:6975
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7070
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:6900
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when the mass delete order event occurred.
Definition Messages.h:6995
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:6946
OnixS::B3::MarketData::UMDF::Messaging::MassDeleteOrders_MBO_52::TemplateId
@ TemplateId
Definition Messages.h:6872
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:6889
OnixS::B3::MarketData::UMDF::Messaging::MatchEventIndicator
Set of indicators that identify some market data events.
Definition Fields.h:1680
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::MultiLegModel::Enum
Enum
Specifies the type of multileg order. Defines whether the security is pre-defined or user-defined.
Definition Fields.h:1239
OnixS::B3::MarketData::UMDF::Messaging::MultiLegPriceMethod::Enum
Enum
Code to represent how the multileg price is to be interpreted when applied to the legs.
Definition Fields.h:1262
OnixS::B3::MarketData::UMDF::Messaging::News_5::languageCode
bool languageCode(StrRef &value) const noexcept
Indicates the language the news is in.
Definition Messages.h:2677
OnixS::B3::MarketData::UMDF::Messaging::News_5::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:2768
OnixS::B3::MarketData::UMDF::Messaging::News_5::News_5
News_5()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::News_5::partNumber
UInt16 partNumber() const noexcept
Number of the part for this message. Starts from 1.
Definition Messages.h:2699
OnixS::B3::MarketData::UMDF::Messaging::News_5::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:2605
OnixS::B3::MarketData::UMDF::Messaging::News_5::TemplateId
@ TemplateId
Definition Messages.h:2561
OnixS::B3::MarketData::UMDF::Messaging::News_5::newsId
bool newsId(NewsID &value) const noexcept
Unique identifier for News message.
Definition Messages.h:2711
OnixS::B3::MarketData::UMDF::Messaging::News_5::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:2656
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::uRLLink
StrRef uRLLink() const noexcept
A URL (Uniform Resource Locator) link to additional information (e.g. http://www.b3....
Definition Messages.h:2757
OnixS::B3::MarketData::UMDF::Messaging::News_5::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:2647
OnixS::B3::MarketData::UMDF::Messaging::News_5::applVerId
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::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:2794
OnixS::B3::MarketData::UMDF::Messaging::News_5::className
static constexpr StrRef className() noexcept
Definition Messages.h:2806
OnixS::B3::MarketData::UMDF::Messaging::News_5::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:2780
OnixS::B3::MarketData::UMDF::Messaging::News_5::origTime
bool origTime(UTCTimestampNanos &value) const noexcept
Time of message origination.
Definition Messages.h:2721
OnixS::B3::MarketData::UMDF::Messaging::News_5::newsSource
NewsSource::Enum newsSource() const noexcept
Source of the News.
Definition Messages.h:2666
OnixS::B3::MarketData::UMDF::Messaging::News_5::text
StrRef text() const noexcept
Free format text string.
Definition Messages.h:2749
OnixS::B3::MarketData::UMDF::Messaging::News_5::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:2816
OnixS::B3::MarketData::UMDF::Messaging::News_5::totalTextLength
UInt32 totalTextLength() const noexcept
Total size, in bytes, for the text of a News message.
Definition Messages.h:2731
OnixS::B3::MarketData::UMDF::Messaging::News_5::securityId
bool securityId(SecurityIDOptional &value) const noexcept
Security ID as defined by B3.
Definition Messages.h:2625
OnixS::B3::MarketData::UMDF::Messaging::News_5::partCount
UInt16 partCount() const noexcept
Total number of parts for the text of a News message.
Definition Messages.h:2689
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
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::headline
StrRef headline() const noexcept
The headline of a News message.
Definition Messages.h:2741
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::NullFixed8
Null values definition for optional Fixed8 field.
Definition Composites.h:375
OnixS::B3::MarketData::UMDF::Messaging::NullMaturityMonthYear
Null values definition for optional MaturityMonthYear field.
Definition Composites.h:1016
OnixS::B3::MarketData::UMDF::Messaging::NullPercentage
Null values definition for optional Percentage field.
Definition Composites.h:241
OnixS::B3::MarketData::UMDF::Messaging::NullPriceOffset8Optional
Null values definition for optional PriceOffset8Optional field.
Definition Composites.h:454
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::NullUTCTimestampSeconds
Null values definition for optional UTCTimestampSeconds field.
Definition Composites.h:816
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::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:5925
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:5803
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:5901
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:5776
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::mDEntrySize
Quantity mDEntrySize() const noexcept
Indicates volume of contracts currently open.
Definition Messages.h:5891
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Open Interest.
Definition Messages.h:5872
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:5852
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:5756
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::TemplateId
@ TemplateId
Definition Messages.h:5759
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:5787
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:5822
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::OpenInterest_29
OpenInterest_29()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:5843
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:5813
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:5912
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:5954
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::className
static constexpr StrRef className() noexcept
Definition Messages.h:5966
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5939
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:5976
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:5863
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:5765
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:5881
OnixS::B3::MarketData::UMDF::Messaging::OpenInterest_29::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:5833
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:3097
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:2950
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:3073
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::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Opening Price.
Definition Messages.h:3020
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::TemplateId
@ TemplateId
Definition Messages.h:2906
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:2999
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:2903
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::mDEntryPx
Price mDEntryPx() const noexcept
Value of the statistics.
Definition Messages.h:3039
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:2969
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:2990
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::netChgPrevDay
bool netChgPrevDay(PriceOffset8Optional &value) const noexcept
Net change from previous trading day’s closing price vs.
Definition Messages.h:3051
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::applVerId
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::OpeningPrice_15::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:3084
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:3126
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::className
static constexpr StrRef className() noexcept
Definition Messages.h:3138
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:3111
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::mDUpdateAction
UpdateAction::Enum mDUpdateAction() const noexcept
Update Action (NEW or DELETE).
Definition Messages.h:3009
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::openCloseSettlFlag
OpenCloseSettlFlag::Enum openCloseSettlFlag() const noexcept
Identifies if the opening price represents or not a daily opening price.
Definition Messages.h:3029
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:3148
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:3063
OnixS::B3::MarketData::UMDF::Messaging::OpeningPrice_15::securityIdSource
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::OpeningPrice_15
OpeningPrice_15(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition Messages.h:2923
OnixS::B3::MarketData::UMDF::Messaging::OptPayoutType::Enum
Enum
Indicates the type of payout that will result from an in-the-money option.
Definition Fields.h:1453
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6507
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:6330
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::TemplateId
@ TemplateId
Definition Messages.h:6286
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::mDEntrySize
Quantity mDEntrySize() const noexcept
Displayed quantity or volume represented by the Market Data Entry.
Definition Messages.h:6422
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:6380
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:6283
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::secondaryOrderId
OrderID secondaryOrderId() const noexcept
Exchange-generated identifier of the order that updates with each order modification event involving ...
Definition Messages.h:6460
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:6349
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:6370
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:6340
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:6471
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:6537
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::className
static constexpr StrRef className() noexcept
Definition Messages.h:6549
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6522
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::mDEntryType
EntryType::Enum mDEntryType() const noexcept
Entry Type (BID or OFFER).
Definition Messages.h:6400
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::mDUpdateAction
UpdateAction::Enum mDUpdateAction() const noexcept
Update Action (NEW, CHANGE).
Definition Messages.h:6390
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:6559
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::mDInsertTimestamp
bool mDInsertTimestamp(UTCTimestampNanos &value) const noexcept
The date and time when the order was inserted or re- inserted into the order book or manually altered...
Definition Messages.h:6444
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:6303
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:6314
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:6292
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::mDEntryPrevSize
bool mDEntryPrevSize(QuantityOptional &value) const noexcept
Previously displayed quantity or volume represented by the Market Data Entry.
Definition Messages.h:6495
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::enteringFirm
bool enteringFirm(FirmOptional &value) const noexcept
Identifies the broker firm.
Definition Messages.h:6432
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when the order event occurred.
Definition Messages.h:6481
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:6360
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::mDEntryPx
bool mDEntryPx(PriceOptional &value) const noexcept
Price per share or contract.
Definition Messages.h:6411
OnixS::B3::MarketData::UMDF::Messaging::Order_MBO_50::Order_MBO_50
Order_MBO_50()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::PriceBandMidpointPriceType::Enum
Enum
Band Midpoint Type, used with Auction Price Banding.
Definition Fields.h:932
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::lowLimitPrice
bool lowLimitPrice(PriceOptional &value) const noexcept
Allowable low limit price for the trading day.
Definition Messages.h:4436
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:4495
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:4318
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:4471
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::priceBandType
bool priceBandType(PriceBandType::Enum &value) const noexcept
Indicates the type of price banding (tunnel).
Definition Messages.h:4396
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::priceBandMidpointPriceType
bool priceBandMidpointPriceType(PriceBandMidpointPriceType::Enum &value) const noexcept
Band Midpoint Type, used with Auction Price Banding.
Definition Messages.h:4422
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::priceLimitType
bool priceLimitType(PriceLimitType::Enum &value) const noexcept
Describes how the price limits are expressed.
Definition Messages.h:4408
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Price Band.
Definition Messages.h:4387
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::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:4367
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:4271
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::tradingReferencePrice
bool tradingReferencePrice(Fixed8 &value) const noexcept
Reference price for the current trading price range.
Definition Messages.h:4461
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:4337
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:4358
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::applVerId
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::PriceBand_22::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:4482
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:4521
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::className
static constexpr StrRef className() noexcept
Definition Messages.h:4533
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4507
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4543
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::highLimitPrice
bool highLimitPrice(PriceOptional &value) const noexcept
Allowable high limit price for the trading day.
Definition Messages.h:4449
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:4378
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::TemplateId
@ TemplateId
Definition Messages.h:4274
OnixS::B3::MarketData::UMDF::Messaging::PriceBand_22::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:4348
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::Product::Enum
Enum
Indicates the type of product the security is associated with.
Definition Fields.h:427
OnixS::B3::MarketData::UMDF::Messaging::PutOrCall::Enum
Enum
Indicates whether an option contract is a put or call.
Definition Fields.h:563
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::minimalBlockLength
static constexpr BlockLength minimalBlockLength(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(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition Messages.h:4015
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:4053
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:4158
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Quantity Band.
Definition Messages.h:4122
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:4102
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::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:4072
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::maxTradeVol
bool maxTradeVol(QuantityVolumeOptional &value) const noexcept
The maximum order quantity that can be submitted for a security.
Definition Messages.h:4147
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:4093
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::applVerId
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::QuantityBand_21::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:4169
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:4211
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::className
static constexpr StrRef className() noexcept
Definition Messages.h:4223
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:4196
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::avgDailyTradedQty
bool avgDailyTradedQty(QuantityVolumeOptional &value) const noexcept
Daily average shares traded within 30 days – equity market only.
Definition Messages.h:4133
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:4233
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:4113
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::QuantityBand_21
QuantityBand_21()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::QuantityBand_21::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:4083
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::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:1646
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::InstrAttribsEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:1659
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::InstrAttribsEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1632
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::InstrAttribsEntry::instrAttribType
InstrAttribType::Enum instrAttribType() const noexcept
Code to represent the type of instrument attributes.
Definition Messages.h:1609
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::InstrAttribsEntry::instrAttribValue
InstrAttribValue::Enum instrAttribValue() const noexcept
Attribute value appropriate to the InstrAttribType (871) field.
Definition Messages.h:1620
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::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:1553
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::legSymbol
StrRef legSymbol() const noexcept
Leg symbol.
Definition Messages.h:1526
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::legSide
Side::Enum legSide() const noexcept
Side of this leg.
Definition Messages.h:1516
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::legSecurityId
SecurityID legSecurityId() const noexcept
Leg's security ID.
Definition Messages.h:1465
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::LegsEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:1566
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1539
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::legSecurityIdSource
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::legSecurityType
SecurityType::Enum legSecurityType() const noexcept
Leg's security type.
Definition Messages.h:1506
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::legRatioQty
bool legRatioQty(RatioQty &value) const noexcept
Ratio of quantity for this leg relative to the entire security.
Definition Messages.h:1496
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::LegsEntry::legSecurityExchange
static constexpr StrRef legSecurityExchange() noexcept
Leg's Exchange Code.
Definition Messages.h:1487
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:1410
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::underlyingSymbol
StrRef underlyingSymbol() const noexcept
Underlying instrument's ticker symbol.
Definition Messages.h:1383
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::underlyingSecurityExchange
static constexpr StrRef underlyingSecurityExchange() noexcept
Underlying instrument's Exchange Code.
Definition Messages.h:1375
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::underlyingSecurityId
SecurityID underlyingSecurityId() const noexcept
Underlying instrument's security ID.
Definition Messages.h:1353
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::underlyingSecurityIdSource
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::UnderlyingsEntry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:1337
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:1423
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::UnderlyingsEntry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:1396
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::settlCurrency
bool settlCurrency(StrRef &value) const noexcept
Currency used for the settlement.
Definition Messages.h:2166
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::minCrossQty
bool minCrossQty(QuantityOptional &value) const noexcept
Minimum quantity of a cross order for the security.
Definition Messages.h:2322
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::tickSizeDenominator
bool tickSizeDenominator(UInt8 &value) const noexcept
Number of decimals for pricing the instrument.
Definition Messages.h:2198
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::multiLegPriceMethod
bool multiLegPriceMethod(MultiLegPriceMethod::Enum &value) const noexcept
Defines the method used when applying the multileg price to the legs.
Definition Messages.h:2311
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::lastFragment
bool lastFragment(Boolean::Enum &value) const noexcept
Indicates whether this message is the last in the sequence of messages.
Definition Messages.h:2285
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:2398
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securitySubType
UInt16 securitySubType() const noexcept
Instrument's security sub type.
Definition Messages.h:1806
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::securityExchange
StrRef securityExchange() const noexcept
Exchange Code.
Definition Messages.h:1741
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::contractMultiplier
bool contractMultiplier(Fixed8 &value) const noexcept
Specifies the ratio or multiply factor to convert from “nominal” units (e.g.
Definition Messages.h:1849
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityIdSource
SecurityIDSource::Enum securityIdSource() const noexcept
Identifies the class of the SecurityID.
Definition Messages.h:1752
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:1713
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::product
Product::Enum product() const noexcept
Type of product.
Definition Messages.h:2208
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::maturityDate
bool maturityDate(Date &value) const noexcept
Date of instrument maturity.
Definition Messages.h:1968
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::priceType
bool priceType(PriceType::Enum &value) const noexcept
Price type of the instrument.
Definition Messages.h:2240
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::optPayoutType
bool optPayoutType(OptPayoutType::Enum &value) const noexcept
Indicates the type of payout that will result from an in- the-money option.
Definition Messages.h:2347
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityGroup
StrRef securityGroup() const noexcept
Security Group.
Definition Messages.h:1762
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityDesc
StrRef securityDesc() const noexcept
Non-normative textual description for the financial instrument.
Definition Messages.h:2387
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::issueDate
Date issueDate() const noexcept
The date on which the security is issued/activated.
Definition Messages.h:1958
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::maturityMonthYear
bool maturityMonthYear(MaturityMonthYear &value) const noexcept
Week, month and year of the maturity (used for standardized futures and options).
Definition Messages.h:2124
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityUpdateAction
SecurityUpdateAction::Enum securityUpdateAction() const noexcept
Action used when updating the security.
Definition Messages.h:1785
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::TemplateId
@ TemplateId
Definition Messages.h:1321
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::impliedMarketIndicator
bool impliedMarketIndicator(ImpliedMarketIndicator::Enum &value) const noexcept
Indicates that an implied order can be created for the instrument.
Definition Messages.h:2334
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::lotType
bool lotType(LotType::Enum &value) const noexcept
Lot type.
Definition Messages.h:2188
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::sharesIssued
bool sharesIssued(UInt64NULL &value) const noexcept
Share capital.
Definition Messages.h:1887
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::corporateActionEventId
bool corporateActionEventId(UInt32NULL &value) const noexcept
Corporate Action Event ID.
Definition Messages.h:1948
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::minPriceIncrement
bool minPriceIncrement(Fixed8 &value) const noexcept
Number of minimum price increments.
Definition Messages.h:1827
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::marketSegmentId
bool marketSegmentId(MarketSegmentID &value) const noexcept
Market segment.
Definition Messages.h:2250
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::totNoRelatedSym
UInt32 totNoRelatedSym() const noexcept
Total number of instruments to be returned in the current replay loop.
Definition Messages.h:1817
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::contractSettlMonth
bool contractSettlMonth(MaturityMonthYear &value) const noexcept
Specifies when the contract will settle.
Definition Messages.h:2134
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:1731
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::startDate
bool startDate(Date &value) const noexcept
Start date of a financing deal, i.e.
Definition Messages.h:1999
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::countryOfIssue
bool countryOfIssue(StrRef &value) const noexcept
ISO 3166-1 alpha-2 country code.
Definition Messages.h:1987
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::endDate
bool endDate(Date &value) const noexcept
End date of a financing deal, i.e.
Definition Messages.h:2020
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::applVerId
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::SecurityDefinition_12::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:2425
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::priceDivisor
bool priceDivisor(Fixed8 &value) const noexcept
Value that divides the Price field to produce the actual order price (based on Step of Quotation).
Definition Messages.h:1863
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::settlType
bool settlType(SettlType &value) const noexcept
Order settlement period in days.
Definition Messages.h:2039
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::asset
StrRef asset() const noexcept
Asset associated to the security.
Definition Messages.h:2099
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::className
static constexpr StrRef className() noexcept
Definition Messages.h:2437
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:2411
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::minOrderQty
bool minOrderQty(QuantityOptional &value) const noexcept
Minimum quantity for an order.
Definition Messages.h:1907
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::strikeCurrency
bool strikeCurrency(StrRef &value) const noexcept
Currency of option's strike price.
Definition Messages.h:2155
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:2447
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::clearingHouseId
bool clearingHouseId(ClearingHouseID &value) const noexcept
Clearing House ID.
Definition Messages.h:1897
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityValidityTimestamp
bool securityValidityTimestamp(UTCTimestampSeconds &value) const noexcept
Indicates the UTC timestamp when trading for this security expires, i.e.
Definition Messages.h:1876
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityMatchType
bool securityMatchType(SecurityMatchType::Enum &value) const noexcept
Type of matching that occurred.
Definition Messages.h:2273
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::strikePrice
bool strikePrice(PriceOptional &value) const noexcept
Strike price of an option.
Definition Messages.h:1837
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::putOrCall
bool putOrCall(PutOrCall::Enum &value) const noexcept
Indicates whether an option contract is a put or call.
Definition Messages.h:2230
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::cfiCode
StrRef cfiCode() const noexcept
Classification of Financial Instruments (CFI code) values, which indicate the type of security using ...
Definition Messages.h:2112
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::minTradeVol
bool minTradeVol(QuantityOptional &value) const noexcept
The minimum trading volume for the security.
Definition Messages.h:1938
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityType
SecurityType::Enum securityType() const noexcept
Instrument's security type.
Definition Messages.h:1795
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::currency
StrRef currency() const noexcept
Currency code.
Definition Messages.h:2144
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::maxOrderQty
bool maxOrderQty(QuantityOptional &value) const noexcept
Maximum quantity for an order.
Definition Messages.h:1917
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::isinNumber
bool isinNumber(StrRef &value) const noexcept
ISIN Number.
Definition Messages.h:2088
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::datedDate
bool datedDate(Date &value) const noexcept
The date of the security activation, if different from the IssueDate.
Definition Messages.h:2069
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::minLotSize
bool minLotSize(QuantityOptional &value) const noexcept
Minimum lot size allowed based on lot type specified in LotType(1093).
Definition Messages.h:1928
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::governanceIndicator
bool governanceIndicator(GovernanceIndicator::Enum &value) const noexcept
Corporative Governance Level Indicator.
Definition Messages.h:2261
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::multiLegModel
bool multiLegModel(MultiLegModel::Enum &value) const noexcept
Defines whether the security is pre-defined or user- defined.
Definition Messages.h:2297
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::securityStrategyType
bool securityStrategyType(StrRef &value) const noexcept
Strategy type definition.
Definition Messages.h:2177
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::exerciseStyle
bool exerciseStyle(ExerciseStyle::Enum &value) const noexcept
Exercise Style.
Definition Messages.h:2219
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::settlDate
bool settlDate(Date &value) const noexcept
Specific date of trade settlement.
Definition Messages.h:2049
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::legs
Legs legs() const noexcept
Definition Messages.h:2369
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::instrAttribs
InstrAttribs instrAttribs() const noexcept
Definition Messages.h:2377
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::symbol
StrRef symbol() const noexcept
Instrument's ticker symbol.
Definition Messages.h:1773
OnixS::B3::MarketData::UMDF::Messaging::SecurityDefinition_12::underlyings
Underlyings underlyings() const noexcept
Definition Messages.h:2359
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::tradingSessionId
TradingSessionID::Enum tradingSessionId() const noexcept
Identifier for trading session.
Definition Messages.h:1160
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:1229
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::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:1120
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::tradSesOpenTime
bool tradSesOpenTime(UTCTimestampNanos &value) const noexcept
Estimated end of the current auction.
Definition Messages.h:1206
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::securityGroup
StrRef securityGroup() const noexcept
Security Group.
Definition Messages.h:1138
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::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:1150
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::applVerId
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::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:1258
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::className
static constexpr StrRef className() noexcept
Definition Messages.h:1270
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:1243
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::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:1280
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:1195
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::tradingSessionSubId
TradingSessionSubID::Enum tradingSessionSubId() const noexcept
Phase related to a given SecurityGroup.
Definition Messages.h:1171
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when phase of the security group changed.
Definition Messages.h:1216
OnixS::B3::MarketData::UMDF::Messaging::SecurityGroupPhase_10::securityTradingEvent
bool securityTradingEvent(SecurityTradingEvent::Enum &value) const noexcept
Indicates if the trading session changed in order to reset some statistics for this group.
Definition Messages.h:1183
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:1357
OnixS::B3::MarketData::UMDF::Messaging::SecurityMatchType::Enum
Enum
Type of matching that occurred. Required for Special Auctions.
Definition Fields.h:736
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::tradingSessionId
TradingSessionID::Enum tradingSessionId() const noexcept
Identifier for trading session.
Definition Messages.h:901
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:984
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:842
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::tradSesOpenTime
bool tradSesOpenTime(UTCTimestampNanos &value) const noexcept
Estimated end of the current auction.
Definition Messages.h:950
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::TemplateId
@ TemplateId
Definition Messages.h:798
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:891
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::securityTradingStatus
SecurityTradingStatus::Enum securityTradingStatus() const noexcept
Status related to a given instrument.
Definition Messages.h:912
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:795
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:861
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::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:882
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::applVerId
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::SecurityStatus_3::SecurityStatus_3
SecurityStatus_3()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:971
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:1013
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::className
static constexpr StrRef className() noexcept
Definition Messages.h:1025
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:998
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:1035
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:939
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when status of the security changed.
Definition Messages.h:960
OnixS::B3::MarketData::UMDF::Messaging::SecurityStatus_3::securityIdSource
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::securityTradingEvent
bool securityTradingEvent(SecurityTradingEvent::Enum &value) const noexcept
Identifies an event related to a Trading.
Definition Messages.h:927
OnixS::B3::MarketData::UMDF::Messaging::SecurityTradingEvent::Enum
Enum
Identifies an event related to a Trade. This tag is also used to mark when an instrument state is kep...
Definition Fields.h:811
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::SecurityUpdateAction::Enum
Enum
Action used when updating the security.
Definition Fields.h:371
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::newSeqNo
static constexpr SeqNum1 newSeqNo() noexcept
New sequence number. Always one.
Definition Messages.h:109
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:120
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:90
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::applVerId
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::SequenceReset_1::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:146
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::className
static constexpr StrRef className() noexcept
Definition Messages.h:158
OnixS::B3::MarketData::UMDF::Messaging::SequenceReset_1::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:132
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::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:168
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:285
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::nextSeqNo
SeqNum nextSeqNo() const noexcept
The next application sequence number in the feed.
Definition Messages.h:272
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:253
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::applVerId
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::Sequence_2::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:311
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::className
static constexpr StrRef className() noexcept
Definition Messages.h:323
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:297
OnixS::B3::MarketData::UMDF::Messaging::Sequence_2::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:333
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::SettlementPrice_28::openCloseSettlFlag
bool openCloseSettlFlag(OpenCloseSettlFlag::Enum &value) const noexcept
Identifies if the settlement price represents a daily, preliminary or an entry from previous business...
Definition Messages.h:5604
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:5667
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:5494
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:5592
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::priceType
bool priceType(PriceType::Enum &value) const noexcept
Code to represent the price type.
Definition Messages.h:5615
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Settlement Price.
Definition Messages.h:5563
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:5543
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:5447
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::mDEntryPx
Price mDEntryPx() const noexcept
Settlement Price.
Definition Messages.h:5582
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:5478
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:5513
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::settlPriceType
SettlPriceType::Enum settlPriceType() const noexcept
Type of settlement price: FINAL, THEORETICAL or UPDATED.
Definition Messages.h:5625
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::SettlementPrice_28
SettlementPrice_28()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::settlDate
bool settlDate(Timestamp &value) const noexcept
Specific date related to published settlement price.
Definition Messages.h:5646
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:5534
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:5504
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:5636
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:5696
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::className
static constexpr StrRef className() noexcept
Definition Messages.h:5708
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:5682
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::TemplateId
@ TemplateId
Definition Messages.h:5450
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:5467
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:5718
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW) - always replace.
Definition Messages.h:5554
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:5572
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:5456
OnixS::B3::MarketData::UMDF::Messaging::SettlementPrice_28::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:5524
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:6193
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:6061
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:6023
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:6014
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:6045
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:6080
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::totNumStats
UInt16 totNumStats() const noexcept
Total number of statistics (incremental and security status messages) that constitute this snapshot.
Definition Messages.h:6154
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::totNumOffers
UInt32 totNumOffers() const noexcept
Total number of ask orders that constitute this snapshot.
Definition Messages.h:6143
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::totNumReports
UInt32 totNumReports() const noexcept
Total number of snapshots to be returned in the current replay loop.
Definition Messages.h:6123
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:6101
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::lastSequenceVersion
bool lastSequenceVersion(UInt16NULL &value) const noexcept
The last processed packet sequence version of the incremental channel as of the time the snapshot was...
Definition Messages.h:6180
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:6071
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::lastMsgSeqNumProcessed
SeqNum lastMsgSeqNumProcessed() const noexcept
The last processed packet sequence number of the incremental channel as of the time the snapshot was ...
Definition Messages.h:6112
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:6222
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::TemplateId
@ TemplateId
Definition Messages.h:6017
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::className
static constexpr StrRef className() noexcept
Definition Messages.h:6234
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:6034
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:6207
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:6244
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::lastRptSeq
bool lastRptSeq(RptSeq &value) const noexcept
Last processed RptSeq (sequence number per instrument update) for this instrument.
Definition Messages.h:6167
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::totNumBids
UInt32 totNumBids() const noexcept
Total number of bid orders that constitute this snapshot.
Definition Messages.h:6133
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Header_30::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:6091
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_Orders_MBO_71::Entry::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition Messages.h:8807
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::mDEntrySize
Quantity mDEntrySize() const noexcept
Displayed quantity or volume represented by the Market Data Entry.
Definition Messages.h:8719
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:8778
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::secondaryOrderId
OrderID secondaryOrderId() const noexcept
Exchange-generated identifier of the order that updates with each order modification event involving ...
Definition Messages.h:8757
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::Base
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition Messages.h:8691
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::className
static constexpr StrRef className() noexcept
Entity class name.
Definition Messages.h:8820
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition Messages.h:8792
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::mDEntryType
EntryType::Enum mDEntryType() const noexcept
Entry Type (BID or OFFER).
Definition Messages.h:8767
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:8695
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::mDInsertTimestamp
bool mDInsertTimestamp(UTCTimestampNanos &value) const noexcept
The date and time when the order was inserted or re- inserted into the order book or manually altered...
Definition Messages.h:8741
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::enteringFirm
bool enteringFirm(FirmOptional &value) const noexcept
Identifies the broker firm.
Definition Messages.h:8729
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entry::mDEntryPx
bool mDEntryPx(PriceOptional &value) const noexcept
Price per share or contract.
Definition Messages.h:8708
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:8858
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:8933
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Entries
SbeGroup< Entry, GroupSizeEncoding, MessageSize > Entries
Repeating group containing Entry entries.
Definition Messages.h:8830
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:8874
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:8672
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:8847
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:8893
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::entries
Entries entries() const noexcept
Definition Messages.h:8922
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:8914
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:8884
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:8959
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::className
static constexpr StrRef className() noexcept
Definition Messages.h:8971
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:8945
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:8675
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:8981
OnixS::B3::MarketData::UMDF::Messaging::SnapshotFullRefresh_Orders_MBO_71::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:8904
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:8836
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::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:3375
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:3233
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::TemplateId
@ TemplateId
Definition Messages.h:3189
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::mDEntryTimestamp
bool mDEntryTimestamp(UTCTimestampNanos &value) const noexcept
Date and time of market data entry.
Definition Messages.h:3351
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::mDEntrySize
bool mDEntrySize(QuantityOptional &value) const noexcept
Theoretical Opening Quantity.
Definition Messages.h:3341
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Opening Price.
Definition Messages.h:3303
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::openCloseSettlFlag
static constexpr OpenCloseSettlFlag::Enum openCloseSettlFlag() noexcept
Indicates this is a theoretical opening price.
Definition Messages.h:3312
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:3282
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:3186
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:3252
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:3273
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::applVerId
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::TheoreticalOpeningPrice_16::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:3362
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:3401
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::className
static constexpr StrRef className() noexcept
Definition Messages.h:3413
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:3387
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::mDUpdateAction
UpdateAction::Enum mDUpdateAction() const noexcept
Update Action (NEW or DELETE).
Definition Messages.h:3292
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:3423
OnixS::B3::MarketData::UMDF::Messaging::TheoreticalOpeningPrice_16::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:3321
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::securityIdSource
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::mDEntryPx
bool mDEntryPx(PriceOptional &value) const noexcept
Theoretical Opening Price.
Definition Messages.h:3331
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::TradeBust_57::tradingSessionId
TradingSessionID::Enum tradingSessionId() const noexcept
Identifier for trading session.
Definition Messages.h:8506
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:8583
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:8402
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:8429
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::TradeBust_57
TradeBust_57()=default
Initializes a blank instance.
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::mDEntrySize
Quantity mDEntrySize() const noexcept
Quantity or volume represented by the Market Data Entry.
Definition Messages.h:8526
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Trade Bust.
Definition Messages.h:8498
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:8478
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::TemplateId
@ TemplateId
Definition Messages.h:8385
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:8382
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::mDEntryPx
Price mDEntryPx() const noexcept
Price of the Market Data Entry.
Definition Messages.h:8516
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:8448
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::tradeId
TradeID tradeId() const noexcept
Contains the unique identifier for this trade per instrument + trading date, as assigned by the excha...
Definition Messages.h:8538
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:8413
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:8469
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:8439
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:8570
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:8612
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::className
static constexpr StrRef className() noexcept
Definition Messages.h:8624
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:8597
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:8634
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (DELETE) = always delete.
Definition Messages.h:8489
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:8549
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:8391
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when the trade bust event occurred.
Definition Messages.h:8559
OnixS::B3::MarketData::UMDF::Messaging::TradeBust_57::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:8459
OnixS::B3::MarketData::UMDF::Messaging::TradeCondition
Set of conditions describing a trade.
Definition Fields.h:1557
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::tradingSessionId
TradingSessionID::Enum tradingSessionId() const noexcept
Identifier for trading session.
Definition Messages.h:7233
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::minimalBlockLength
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition Messages.h:7351
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::messageType
static constexpr MessageType::Enum messageType() noexcept
FIX Message Type.
Definition Messages.h:7156
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:7118
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::mDEntrySize
Quantity mDEntrySize() const noexcept
Quantity or volume represented by the Market Data Entry.
Definition Messages.h:7263
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::mDEntryType
static constexpr EntryType::Enum mDEntryType() noexcept
Entry type: Trade.
Definition Messages.h:7225
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:7112
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::matchEventIndicator
MatchEventIndicator matchEventIndicator() const noexcept
Set of indicators that identify some market data events.
Definition Messages.h:7205
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::Schema
SchemaTraits Schema
Used template schema.
Definition Messages.h:7109
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::mDEntryPx
Price mDEntryPx() const noexcept
Price of the Market Data Entry.
Definition Messages.h:7253
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::mDEntryBuyer
bool mDEntryBuyer(FirmOptional &value) const noexcept
For reporting trades (buying party).
Definition Messages.h:7285
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:7140
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::securityId
SecurityID securityId() const noexcept
Security ID as defined by B3.
Definition Messages.h:7175
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::tradeId
TradeID tradeId() const noexcept
Contains the unique identifier for this trade per instrument + trading date, as assigned by the excha...
Definition Messages.h:7275
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::securityExchange
static constexpr StrRef securityExchange() noexcept
Market to which the symbol belongs.
Definition Messages.h:7196
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:7129
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::applVerId
static constexpr ApplVerID::Enum applVerId() noexcept
Specifies the service pack release being applied at message level.
Definition Messages.h:7166
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::rptSeq
bool rptSeq(RptSeq &value) const noexcept
Sequence number per instrument update.
Definition Messages.h:7338
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::getMinimalVariableFieldsSize
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition Messages.h:7380
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::className
static constexpr StrRef className() noexcept
Definition Messages.h:7392
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::blockLength
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition Messages.h:7365
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::fixType
static constexpr StrRef fixType() noexcept
FIX message type.
Definition Messages.h:7402
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::mDUpdateAction
static constexpr UpdateAction::Enum mDUpdateAction() noexcept
Update Action (NEW).
Definition Messages.h:7216
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::trdSubType
bool trdSubType(TrdSubType::Enum &value) const noexcept
Sub type of trade assigned to a trade.
Definition Messages.h:7316
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::tradeDate
Timestamp tradeDate() const noexcept
Used to specify the trading date for which a set of market data applies.
Definition Messages.h:7306
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::transactTime
bool transactTime(UTCTimestampNanos &value) const noexcept
Timestamp when the trade event occurred.
Definition Messages.h:7327
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::securityIdSource
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition Messages.h:7186
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::tradeCondition
TradeCondition tradeCondition() const noexcept
Set of conditions describing a trade.
Definition Messages.h:7243
OnixS::B3::MarketData::UMDF::Messaging::Trade_53::mDEntrySeller
bool mDEntrySeller(FirmOptional &value) const noexcept
For reporting trades (selling party).
Definition Messages.h:7295
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::TrdSubType::Enum
Enum
Sub type of trade assigned to a trade.
Definition Fields.h:1382
OnixS::B3::MarketData::UMDF::Messaging::UpdateAction::Enum
Enum
Types of Market Data update action.
Definition Fields.h:1013