OnixS C++ B3 BOE Binary Order Entry  1.3.0
API Documentation
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/BOE/ABI.h>
29 
31 
32 /// The client sends the Negotiate message to B3 to initiate a connection. Negotiate is the first message that the client must sent to start the communication between client and gateway through a TCP socket connection.
35 : SbeMessage
36 {
37  /// Used template schema.
39 
40  /// This type alias.
42 
43  /// Message template ID from SBE schema.
44  enum { TemplateId = 1 };
45 
46  /// Initializes a blank instance.
48 
49  /// Initializes an instance over the given memory block.
51  void* data,
52  EncodedLength length,
53  SchemaVersion version = Schema::Version)
54  : SbeMessage(data, length, version)
55  {
56  checkVersion<Schema>(version);
57  checkLength(length, version);
58  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
59  reset();
60  }
61 
62  /// Initializes an instance over the given memory block
63  /// With no variable-length fields initialization
64  /// It is assumed that the user does such an initialization manually.
66  void* data,
67  EncodedLength length,
69  SchemaVersion version = Schema::Version)
70  : SbeMessage(data, length, version)
71  {
72  checkVersion<Schema>(version);
73  checkLength(length, version);
74  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
75  resetVariableFields();
76  }
77 
78  /// Creates an instance over the given memory block.
80  void* data,
81  EncodedLength length,
82  NoInit)
83  : SbeMessage(data, length)
84  {
85  checkCompatibility();
86  }
87 
88  /// Creates an instance over the given SBE message.
89  explicit
91  const SbeMessage& message)
92  : SbeMessage(message)
93  {
94  assert(message.valid());
95 
96  checkCompatibility();
97  }
98 
99  /// Creates an instance over the given memory block.
100  /// Performs no checks.
102  void* data,
103  EncodedLength length,
104  NoInit,
105  NoCheck)
107  : SbeMessage(data, length, NoCheck())
108  {
109  assert(schemaId() == Schema::Id);
110  assert(version() >= Schema::MinimalVersion);
111  assert(TemplateId == templateId());
112  }
113 
114  /// Message type = Negotiate.
119  {
120  return MessageType::Negotiate;
121  }
122 
123  /// Message type = Negotiate.
124 
125  /// Client connection identification on the gateway assigned
126  /// by B3.
130  {
132 
133  return ordinary<SessionID>(offset);
134  }
135 
136  /// Client connection identification on the gateway assigned
137  /// by B3.
138  ThisType& setSessionId(SessionID value)
140  {
142 
143  setOrdinary(offset, value);
144  return *this;
145  }
146 
147  /// Session version identification: unique identification of a
148  /// sequence of messages to be transmitted to/from B3´s
149  /// gateways associated with given SessionId. Need to be
150  /// incremented each time Negotiate message is sent to
151  /// gateway.
155  {
157 
158  return ordinary<SessionVerID>(offset);
159  }
160 
161  /// Session version identification: unique identification of a
162  /// sequence of messages to be transmitted to/from B3´s
163  /// gateways associated with given SessionId. Need to be
164  /// incremented each time Negotiate message is sent to
165  /// gateway.
166  ThisType& setSessionVerId(SessionVerID value)
168  {
170 
171  setOrdinary(offset, value);
172  return *this;
173  }
174 
175  /// Time of request. Sent in number of nanoseconds since Unix
176  /// epoch.
180  {
182 
183  return ordinary<UTCTimestampNanos>(offset);
184  }
185 
186  /// Time of request. Sent in number of nanoseconds since Unix
187  /// epoch.
190  {
192 
193  setOrdinary(offset, value);
194  return *this;
195  }
196 
197  /// Type of flow from client to server. It is a constant value
198  /// = idempotent.
203  {
204  return FlowType::Idempotent;
205  }
206 
207  /// Type of flow from client to server. It is a constant value
208  /// = idempotent.
209 
210  /// Identifies the broker firm that will enter orders.
214  {
216 
217  return ordinary<Firm>(offset);
218  }
219 
220  /// Identifies the broker firm that will enter orders.
221  ThisType& setEnteringFirm(Firm value)
223  {
225 
226  setOrdinary(offset, value);
227  return *this;
228  }
229 
230  /// Identifies the broker firm who executes their orders on
231  /// behalf.
233  bool onbehalfFirm(FirmOptional& value) const
235  {
237 
238  return ordinary(value, offset, NullFirmOptional());
239  }
240 
241  /// Identifies the broker firm who executes their orders on
242  /// behalf.
243  ThisType& setOnbehalfFirm(FirmOptional value)
245  {
247 
248  setOrdinary(offset, value);
249  return *this;
250  }
251 
254  {
256 
257  setOrdinary(offset, NullFirmOptional());
258  return *this;
259  }
260 
261  /// Credentials to identify/authenticate the client. The format is a JSON with the following data: { "auth_type": "basic", "username": "session_id", "access_key": "somepassword" }.
265  {
266  return getVariableLengthField(
267  credentialsAccess(),
268  *this);
269  }
270 
271  /// Source IP from client system.
273  StrRef clientIP() const
275  {
276  return getVariableLengthField(clientIPAccess(), *this);
277  }
278 
279  /// Application name as informed during certification process.
283  {
284  return getVariableLengthField(
285  clientAppNameAccess(),
286  *this);
287  }
288 
289  /// Application version as informed during certification process.
293  {
294  return getVariableLengthField(
295  clientAppVersionAccess(),
296  *this);
297  }
298 
299  /// Credentials to identify/authenticate the client. The format is a JSON with the following data: { "auth_type": "basic", "username": "session_id", "access_key": "somepassword" }.
300  ThisType& setCredentials(StrRef value)
301  {
302  setVariableLengthField(
303  credentialsAccess(),
304  value,
305  *this);
306 
307  return *this;
308  }
309 
310  /// Source IP from client system.
311  ThisType& setClientIP(StrRef value)
312  {
313  setVariableLengthField(
314  clientIPAccess(),
315  value,
316  *this);
317 
318  return *this;
319  }
320 
321  /// Application name as informed during certification process.
322  ThisType& setClientAppName(StrRef value)
323  {
324  setVariableLengthField(
325  clientAppNameAccess(),
326  value,
327  *this);
328 
329  return *this;
330  }
331 
332  /// Application version as informed during certification process.
333  ThisType& setClientAppVersion(StrRef value)
334  {
335  setVariableLengthField(
336  clientAppVersionAccess(),
337  value,
338  *this);
339 
340  return *this;
341  }
342 
343  /// Minimal size of message body in bytes.
346  static
351  {
352  return
353  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
354  28;
355  }
356 
357  /// Size of message body in bytes.
362  {
363  return
364  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
365  minimalBlockLength(version);
366  }
367 
368  /// Minimal variable fields size (when variable-length fields are empty).
372  static
376  {
377  return
378  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
379  static_cast<MessageSize>(CredentialsEncoding::Size) + static_cast<MessageSize>(ClientAppEncoding::Size) + static_cast<MessageSize>(ClientAppEncoding::Size) + static_cast<MessageSize>(ClientAppEncoding::Size);
380  }
381 
382  /// Maximal message size.
386  static UInt64 getMaxMessageSize(UInt8)
388  {
389  return
391  }
392 
393  /// Reset all variable-length fields if any.
396  {
397  setCredentialsToNull();
398  setClientIPToNull();
399  setClientAppNameToNull();
400  setClientAppVersionToNull();
401  return *this;
402  }
403 
404  /// Reset all variable-length and optional fields if any.
405  ThisType& reset()
407  {
408  setOnbehalfFirmToNull();
409 
410  resetVariableFields();
411  return *this;
412  }
413 
414  /// \return class name.
418  static const Char* className()
419  {
420  return "Negotiate1";
421  }
422 
423  /// FIX message type.
427  static StrRef fixType()
429  {
430  return constructStrRef("Negotiate1");
431  }
432 
433  /// \return a human-readable presentation.
435  std::string toString() const;
436 
437  /// \return the end of the message.
439  const void* tail() const
441  {
442  return
443  toOpaquePtr(
444  (clientAppVersion().end()));
445  }
446 
447  /// \return the size occupied by the message.
451  {
452  return
453  SbeMessage::calculateBinarySize(tail());
454  }
455 
456 private:
457  void checkLength(
458  EncodedLength length, SchemaVersion version) const
459  {
460  const EncodedLength minimalRequiredLength =
461  minimalBlockLength(version) +
462  MessageHeader::Size +
463  getMinimalVariableFieldsSize(version);
464 
465  checkBinaryLength(
466  *this, length, minimalRequiredLength);
467  }
468 
469  /// Checks variable fields consistency.
470  void checkVarLenFields() const
471  {
472  variableLengthFields().
473  checkTail<CredentialsEncoding>().
474  checkTail<ClientAppEncoding>().
475  checkTail<ClientAppEncoding>().
476  checkTail<ClientAppEncoding>();
477  }
478 
479  void checkCompatibility() const
480  {
481  assert(TemplateId == templateId());
482 
483  checkSchema<Schema>(schemaId(), version());
484  checkLength(bufferSize(), version());
485  checkVarLenFields();
486  }
487 
488  /// Access helper.
489  struct credentialsAccess
490  {
491  CredentialsEncoding& operator()(const Negotiate1& obj) const
493  {
494  return obj.
495  variableLengthFields().
496  head<CredentialsEncoding>();
497  }
498  };
499 
500  /// Access helper.
501  struct clientIPAccess
502  {
503  ClientAppEncoding& operator()(const Negotiate1& obj) const
505  {
506  return obj.
507  variableLengthFields().
508  tail<CredentialsEncoding>().
509  head<ClientAppEncoding>();
510  }
511  };
512 
513  /// Access helper.
514  struct clientAppNameAccess
515  {
516  ClientAppEncoding& operator()(const Negotiate1& obj) const
518  {
519  return obj.
520  variableLengthFields().
521  tail<CredentialsEncoding>().
522  tail<ClientAppEncoding>().
523  head<ClientAppEncoding>();
524  }
525  };
526 
527  /// Access helper.
528  struct clientAppVersionAccess
529  {
530  ClientAppEncoding& operator()(const Negotiate1& obj) const
532  {
533  return obj.
534  variableLengthFields().
535  tail<CredentialsEncoding>().
536  tail<ClientAppEncoding>().
537  tail<ClientAppEncoding>().
538  head<ClientAppEncoding>();
539  }
540  };
541 
542  /// Reset the field.
543  /// All the following data will be invalidated.
544  ThisType& setCredentialsToNull()
546  {
547  setVariableLengthFieldToNull(
548  credentialsAccess(),
549  *this);
550 
551  return *this;
552  }
553 
554  /// Reset the field.
555  /// All the following data will be invalidated.
556  ThisType& setClientIPToNull()
558  {
559  setVariableLengthFieldToNull(clientIPAccess(), *this);
560 
561  return *this;
562  }
563 
564  /// Reset the field.
565  /// All the following data will be invalidated.
566  ThisType& setClientAppNameToNull()
568  {
569  setVariableLengthFieldToNull(
570  clientAppNameAccess(),
571  *this);
572 
573  return *this;
574  }
575 
576  /// Reset the field.
577  /// All the following data will be invalidated.
578  ThisType& setClientAppVersionToNull()
580  {
581  setVariableLengthFieldToNull(
582  clientAppVersionAccess(),
583  *this);
584 
585  return *this;
586  }
587 };
588 
589 /// The NegotiationResponse message is sent when a Negotiate message from the client is accepted by B3.
592 : SbeMessage
593 {
594  /// Used template schema.
596 
597  /// This type alias.
599 
600  /// Message template ID from SBE schema.
601  enum { TemplateId = 2 };
602 
603  /// Initializes a blank instance.
605 
606  /// Initializes an instance over the given memory block.
608  void* data,
609  EncodedLength length,
610  SchemaVersion version = Schema::Version)
611  : SbeMessage(data, length, version)
612  {
613  checkVersion<Schema>(version);
614  checkLength(length, version);
615  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
616  reset();
617  }
618 
619  /// Initializes an instance over the given memory block
620  /// With no variable-length fields initialization
621  /// It is assumed that the user does such an initialization manually.
623  void* data,
624  EncodedLength length,
625  NoFieldsInit,
626  SchemaVersion version = Schema::Version)
627  : SbeMessage(data, length, version)
628  {
629  checkVersion<Schema>(version);
630  checkLength(length, version);
631  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
632  resetVariableFields();
633  }
634 
635  /// Creates an instance over the given memory block.
637  void* data,
638  EncodedLength length,
639  NoInit)
640  : SbeMessage(data, length)
641  {
642  checkCompatibility();
643  }
644 
645  /// Creates an instance over the given SBE message.
646  explicit
648  const SbeMessage& message)
649  : SbeMessage(message)
650  {
651  assert(message.valid());
652 
653  checkCompatibility();
654  }
655 
656  /// Creates an instance over the given memory block.
657  /// Performs no checks.
659  void* data,
660  EncodedLength length,
661  NoInit,
662  NoCheck)
664  : SbeMessage(data, length, NoCheck())
665  {
666  assert(schemaId() == Schema::Id);
667  assert(version() >= Schema::MinimalVersion);
668  assert(TemplateId == templateId());
669  }
670 
671  /// Message type = NegotiateResponse.
676  {
677  return MessageType::NegotiateResponse;
678  }
679 
680  /// Message type = NegotiateResponse.
681 
682  /// Client connection identification on the gateway assigned
683  /// by B3.
687  {
689 
690  return ordinary<SessionID>(offset);
691  }
692 
693  /// Client connection identification on the gateway assigned
694  /// by B3.
695  ThisType& setSessionId(SessionID value)
697  {
699 
700  setOrdinary(offset, value);
701  return *this;
702  }
703 
704  /// Session version identification: unique identification of a
705  /// sequence of messages to be transmitted to/from B3´s
706  /// gateways associated with given SessionId. Need to be
707  /// incremented each time Negotiate message is sent to
708  /// gateway.
712  {
714 
715  return ordinary<SessionVerID>(offset);
716  }
717 
718  /// Session version identification: unique identification of a
719  /// sequence of messages to be transmitted to/from B3´s
720  /// gateways associated with given SessionId. Need to be
721  /// incremented each time Negotiate message is sent to
722  /// gateway.
723  ThisType& setSessionVerId(SessionVerID value)
725  {
727 
728  setOrdinary(offset, value);
729  return *this;
730  }
731 
732  /// Matches Negotiate timestamp.
736  {
738 
739  return ordinary<UTCTimestampNanos>(offset);
740  }
741 
742  /// Matches Negotiate timestamp.
745  {
747 
748  setOrdinary(offset, value);
749  return *this;
750  }
751 
752  /// Type of flow from client to server. It is a constant value
753  /// = recoverable.
758  {
759  return FlowType::Recoverable;
760  }
761 
762  /// Type of flow from client to server. It is a constant value
763  /// = recoverable.
764 
765  /// Type of flow from client to server. It is a constant value
766  /// = idempotent.
771  {
772  return FlowType::Idempotent;
773  }
774 
775  /// Type of flow from client to server. It is a constant value
776  /// = idempotent.
777 
778  /// Identifies the broker firm that will enter orders.
782  {
784 
785  return ordinary<Firm>(offset);
786  }
787 
788  /// Identifies the broker firm that will enter orders.
789  ThisType& setEnteringFirm(Firm value)
791  {
793 
794  setOrdinary(offset, value);
795  return *this;
796  }
797 
798  /// Identifies the semantic version of the schema used in this
799  /// session.
801  bool semanticVersion(Version& value) const
803  {
806 
807  return ordinary(value, offset, NullVersion(), since);
808  }
809 
810  /// Identifies the semantic version of the schema used in this
811  /// session.
812  ThisType& setSemanticVersion(Version value)
813  {
816 
817  setOrdinary(offset, value, since);
818  return *this;
819  }
820 
822  {
825 
826  setOrdinary(offset, NullVersion(), since);
827  return *this;
828  }
829 
830  /// Minimal size of message body in bytes.
835  {
836  return
837  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
838  (version >= 4)
839  ? 28
840  : 24;
841  }
842 
843  /// Size of message body in bytes.
848  {
849  return
850  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
851  minimalBlockLength(version);
852  }
853 
854  /// Minimal variable fields size (when variable-length fields are empty).
858  static
862  {
863  return
864  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
865  0;
866  }
867 
868  /// Maximal message size.
872  static UInt64 getMaxMessageSize(UInt8)
874  {
875  return
876  static_cast<UInt64>(MessageHeaderBuilder::Size) +
877  blockLength(Schema::Version);
878  }
879 
880  /// Reset all variable-length fields if any.
883  {
884  return *this;
885  }
886 
887  /// Reset all variable-length and optional fields if any.
888  ThisType& reset()
890  {
891  if (version() >= 4)
892  {
893  setSemanticVersionToNull();
894  }
895 
896  resetVariableFields();
897  return *this;
898  }
899 
900  /// \return class name.
904  static const Char* className()
905  {
906  return "NegotiateResponse2";
907  }
908 
909  /// FIX message type.
913  static StrRef fixType()
915  {
916  return constructStrRef("NegotiateResponse2");
917  }
918 
919  /// \return a human-readable presentation.
921  std::string toString() const;
922 
923  /// \return the end of the message.
925  const void* tail() const
927  {
928  return
929  toOpaquePtr(
930  advanceByBytes(
931  binary(),
932  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
933  MessageHeader::Size));
934  }
935 
936  /// \return the size occupied by the message.
940  {
941  return
942  SbeMessage::calculateBinarySize(tail());
943  }
944 
945 private:
946  void checkLength(
947  EncodedLength length, SchemaVersion version) const
948  {
949  const EncodedLength minimalRequiredLength =
950  minimalBlockLength(version) +
951  MessageHeader::Size +
952  getMinimalVariableFieldsSize(version);
953 
954  checkBinaryLength(
955  *this, length, minimalRequiredLength);
956  }
957 
958  void checkCompatibility() const
959  {
960  assert(TemplateId == templateId());
961 
962  checkSchema<Schema>(schemaId(), version());
963  checkLength(bufferSize(), version());
964  }
965 };
966 
967 /// NegotiateReject message is sent when B3 rejects a Negotiate message sent by the client.
970 : SbeMessage
971 {
972  /// Used template schema.
974 
975  /// This type alias.
977 
978  /// Message template ID from SBE schema.
979  enum { TemplateId = 3 };
980 
981  /// Initializes a blank instance.
983 
984  /// Initializes an instance over the given memory block.
986  void* data,
987  EncodedLength length,
988  SchemaVersion version = Schema::Version)
989  : SbeMessage(data, length, version)
990  {
991  checkVersion<Schema>(version);
992  checkLength(length, version);
993  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
994  reset();
995  }
996 
997  /// Initializes an instance over the given memory block
998  /// With no variable-length fields initialization
999  /// It is assumed that the user does such an initialization manually.
1001  void* data,
1002  EncodedLength length,
1003  NoFieldsInit,
1004  SchemaVersion version = Schema::Version)
1005  : SbeMessage(data, length, version)
1006  {
1007  checkVersion<Schema>(version);
1008  checkLength(length, version);
1009  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1010  resetVariableFields();
1011  }
1012 
1013  /// Creates an instance over the given memory block.
1015  void* data,
1016  EncodedLength length,
1017  NoInit)
1018  : SbeMessage(data, length)
1019  {
1020  checkCompatibility();
1021  }
1022 
1023  /// Creates an instance over the given SBE message.
1024  explicit
1026  const SbeMessage& message)
1027  : SbeMessage(message)
1028  {
1029  assert(message.valid());
1030 
1031  checkCompatibility();
1032  }
1033 
1034  /// Creates an instance over the given memory block.
1035  /// Performs no checks.
1037  void* data,
1038  EncodedLength length,
1039  NoInit,
1040  NoCheck)
1042  : SbeMessage(data, length, NoCheck())
1043  {
1044  assert(schemaId() == Schema::Id);
1045  assert(version() >= Schema::MinimalVersion);
1046  assert(TemplateId == templateId());
1047  }
1048 
1049  /// Message type = NegotiateReject.
1054  {
1055  return MessageType::NegotiateReject;
1056  }
1057 
1058  /// Message type = NegotiateReject.
1059 
1060  /// Client connection identification on the gateway assigned
1061  /// by B3.
1065  {
1067 
1068  return ordinary<SessionID>(offset);
1069  }
1070 
1071  /// Client connection identification on the gateway assigned
1072  /// by B3.
1073  ThisType& setSessionId(SessionID value)
1075  {
1077 
1078  setOrdinary(offset, value);
1079  return *this;
1080  }
1081 
1082  /// Session version identification: unique identification of a
1083  /// sequence of messages to be transmitted to/from B3´s
1084  /// gateways associated with given SessionId. Need to be
1085  /// incremented each time Negotiate message is sent to
1086  /// gateway.
1090  {
1092 
1093  return ordinary<SessionVerID>(offset);
1094  }
1095 
1096  /// Session version identification: unique identification of a
1097  /// sequence of messages to be transmitted to/from B3´s
1098  /// gateways associated with given SessionId. Need to be
1099  /// incremented each time Negotiate message is sent to
1100  /// gateway.
1103  {
1105 
1106  setOrdinary(offset, value);
1107  return *this;
1108  }
1109 
1110  /// Matches Negotiate timestamp.
1114  {
1116 
1117  return ordinary<UTCTimestampNanos>(offset);
1118  }
1119 
1120  /// Matches Negotiate timestamp.
1123  {
1125 
1126  setOrdinary(offset, value);
1127  return *this;
1128  }
1129 
1130  /// Type of flow from client to server. It is a constant value
1131  /// = idempotent.
1136  {
1137  return FlowType::Idempotent;
1138  }
1139 
1140  /// Type of flow from client to server. It is a constant value
1141  /// = idempotent.
1142 
1143  /// Identifies the broker firm that will enter orders.
1145  bool enteringFirm(FirmOptional& value) const
1147  {
1149 
1150  return ordinary(value, offset, NullFirmOptional());
1151  }
1152 
1153  /// Identifies the broker firm that will enter orders.
1156  {
1158 
1159  setOrdinary(offset, value);
1160  return *this;
1161  }
1162 
1165  {
1167 
1168  setOrdinary(offset, NullFirmOptional());
1169  return *this;
1170  }
1171 
1172  /// Identifies the code of reject negotiation.
1177  {
1179 
1180  return enumeration<NegotiationRejectCode>(offset);
1181  }
1182 
1183  /// Identifies the code of reject negotiation.
1184  ThisType&
1188  {
1190 
1191  setEnumeration<NegotiationRejectCode>(offset, value);
1192  return *this;
1193  }
1194 
1195  /// The current sessionVerID informed at the first Negotiate
1196  /// message for that specific session.
1198  bool
1200  SessionVerIDOptional& value) const
1202  {
1204 
1205  return ordinary(value, offset, NullSessionVerIDOptional());
1206  }
1207 
1208  /// The current sessionVerID informed at the first Negotiate
1209  /// message for that specific session.
1210  ThisType&
1212  SessionVerIDOptional value)
1214  {
1216 
1217  setOrdinary(offset, value);
1218  return *this;
1219  }
1220 
1223  {
1225 
1226  setOrdinary(offset, NullSessionVerIDOptional());
1227  return *this;
1228  }
1229 
1230  /// Minimal size of message body in bytes.
1233  static
1234  BlockLength
1238  {
1239  return
1240  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
1241  36;
1242  }
1243 
1244  /// Size of message body in bytes.
1247  static
1248  BlockLength
1252  {
1253  return
1254  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
1255  minimalBlockLength(version);
1256  }
1257 
1258  /// Minimal variable fields size (when variable-length fields are empty).
1262  static
1263  MessageSize
1266  {
1267  return
1268  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
1269  0;
1270  }
1271 
1272  /// Maximal message size.
1276  static UInt64 getMaxMessageSize(UInt8)
1278  {
1279  return
1280  static_cast<UInt64>(MessageHeaderBuilder::Size) +
1281  blockLength(Schema::Version);
1282  }
1283 
1284  /// Reset all variable-length fields if any.
1287  {
1288  return *this;
1289  }
1290 
1291  /// Reset all variable-length and optional fields if any.
1292  ThisType& reset()
1294  {
1295  setEnteringFirmToNull();
1296  setCurrentSessionVerIdToNull();
1297 
1298  resetVariableFields();
1299  return *this;
1300  }
1301 
1302  /// \return class name.
1306  static const Char* className()
1307  {
1308  return "NegotiateReject3";
1309  }
1310 
1311  /// FIX message type.
1315  static StrRef fixType()
1317  {
1318  return constructStrRef("NegotiateReject3");
1319  }
1320 
1321  /// \return a human-readable presentation.
1323  std::string toString() const;
1324 
1325  /// \return the end of the message.
1327  const void* tail() const
1329  {
1330  return
1331  toOpaquePtr(
1332  advanceByBytes(
1333  binary(),
1334  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
1335  MessageHeader::Size));
1336  }
1337 
1338  /// \return the size occupied by the message.
1342  {
1343  return
1344  SbeMessage::calculateBinarySize(tail());
1345  }
1346 
1347 private:
1348  void checkLength(
1349  EncodedLength length, SchemaVersion version) const
1350  {
1351  const EncodedLength minimalRequiredLength =
1352  minimalBlockLength(version) +
1353  MessageHeader::Size +
1354  getMinimalVariableFieldsSize(version);
1355 
1356  checkBinaryLength(
1357  *this, length, minimalRequiredLength);
1358  }
1359 
1360  void checkCompatibility() const
1361  {
1362  assert(TemplateId == templateId());
1363 
1364  checkSchema<Schema>(schemaId(), version());
1365  checkLength(bufferSize(), version());
1366  }
1367 };
1368 
1369 /// After negotiation level is complete, the client must send an Establish message to start assigning sequence numbers and also to keep the connection active. Once the connection is established, client can submit orders and quotes.
1371 Establish4
1372 : SbeMessage
1373 {
1374  /// Used template schema.
1376 
1377  /// This type alias.
1379 
1380  /// Message template ID from SBE schema.
1381  enum { TemplateId = 4 };
1382 
1383  /// Initializes a blank instance.
1385 
1386  /// Initializes an instance over the given memory block.
1388  void* data,
1389  EncodedLength length,
1390  SchemaVersion version = Schema::Version)
1391  : SbeMessage(data, length, version)
1392  {
1393  checkVersion<Schema>(version);
1394  checkLength(length, version);
1395  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1396  reset();
1397  }
1398 
1399  /// Initializes an instance over the given memory block
1400  /// With no variable-length fields initialization
1401  /// It is assumed that the user does such an initialization manually.
1403  void* data,
1404  EncodedLength length,
1405  NoFieldsInit,
1406  SchemaVersion version = Schema::Version)
1407  : SbeMessage(data, length, version)
1408  {
1409  checkVersion<Schema>(version);
1410  checkLength(length, version);
1411  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1412  resetVariableFields();
1413  }
1414 
1415  /// Creates an instance over the given memory block.
1417  void* data,
1418  EncodedLength length,
1419  NoInit)
1420  : SbeMessage(data, length)
1421  {
1422  checkCompatibility();
1423  }
1424 
1425  /// Creates an instance over the given SBE message.
1426  explicit
1428  const SbeMessage& message)
1429  : SbeMessage(message)
1430  {
1431  assert(message.valid());
1432 
1433  checkCompatibility();
1434  }
1435 
1436  /// Creates an instance over the given memory block.
1437  /// Performs no checks.
1439  void* data,
1440  EncodedLength length,
1441  NoInit,
1442  NoCheck)
1444  : SbeMessage(data, length, NoCheck())
1445  {
1446  assert(schemaId() == Schema::Id);
1447  assert(version() >= Schema::MinimalVersion);
1448  assert(TemplateId == templateId());
1449  }
1450 
1451  /// Message type = Establish.
1456  {
1457  return MessageType::Establish;
1458  }
1459 
1460  /// Message type = Establish.
1461 
1462  /// Client connection identification on the gateway assigned
1463  /// by B3.
1467  {
1469 
1470  return ordinary<SessionID>(offset);
1471  }
1472 
1473  /// Client connection identification on the gateway assigned
1474  /// by B3.
1475  ThisType& setSessionId(SessionID value)
1477  {
1479 
1480  setOrdinary(offset, value);
1481  return *this;
1482  }
1483 
1484  /// Session version identification: unique identification of a
1485  /// sequence of messages to be transmitted to/from B3´s
1486  /// gateways associated with given SessionId. Need to be
1487  /// incremented each time Negotiate message is sent to
1488  /// gateway.
1492  {
1494 
1495  return ordinary<SessionVerID>(offset);
1496  }
1497 
1498  /// Session version identification: unique identification of a
1499  /// sequence of messages to be transmitted to/from B3´s
1500  /// gateways associated with given SessionId. Need to be
1501  /// incremented each time Negotiate message is sent to
1502  /// gateway.
1505  {
1507 
1508  setOrdinary(offset, value);
1509  return *this;
1510  }
1511 
1512  /// Time of request. Sent in number of nanoseconds since Unix
1513  /// epoch.
1517  {
1519 
1520  return ordinary<UTCTimestampNanos>(offset);
1521  }
1522 
1523  /// Time of request. Sent in number of nanoseconds since Unix
1524  /// epoch.
1527  {
1529 
1530  setOrdinary(offset, value);
1531  return *this;
1532  }
1533 
1534  /// Longest time in milliseconds the initiator should remain
1535  /// silent before sending Sequence message. It should be in
1536  /// the range of 1000 to 60000 (inclusive).
1540  {
1542 
1543  return ordinary<DeltaInMillis>(offset);
1544  }
1545 
1546  /// Longest time in milliseconds the initiator should remain
1547  /// silent before sending Sequence message. It should be in
1548  /// the range of 1000 to 60000 (inclusive).
1551  {
1553 
1554  setOrdinary(offset, value);
1555  return *this;
1556  }
1557 
1558  /// The next application sequence number to be produced by the
1559  /// client.
1563  {
1565 
1566  return ordinary<SeqNum>(offset);
1567  }
1568 
1569  /// The next application sequence number to be produced by the
1570  /// client.
1571  ThisType& setNextSeqNo(SeqNum value)
1573  {
1575 
1576  setOrdinary(offset, value);
1577  return *this;
1578  }
1579 
1580  /// Criteria used to initiate cancel on disconnect mechanism
1581  /// by the gateway.
1586  {
1588 
1589  return enumeration<CancelOnDisconnectType>(offset);
1590  }
1591 
1592  /// Criteria used to initiate cancel on disconnect mechanism
1593  /// by the gateway.
1594  ThisType&
1598  {
1600 
1601  setEnumeration<CancelOnDisconnectType>(offset, value);
1602  return *this;
1603  }
1604 
1605  /// Gateway will not trigger CoD if the customer reconnects
1606  /// within the timeout window (milliseconds) which starts when
1607  /// the triggering event is detected. Range is 0 (as soon as
1608  /// possible) to 60000.
1612  {
1614 
1615  return ordinary<DeltaInMillis>(offset);
1616  }
1617 
1618  /// Gateway will not trigger CoD if the customer reconnects
1619  /// within the timeout window (milliseconds) which starts when
1620  /// the triggering event is detected. Range is 0 (as soon as
1621  /// possible) to 60000.
1624  {
1626 
1627  setOrdinary(offset, value);
1628  return *this;
1629  }
1630 
1631  /// Credentials to identify/authenticate the client. The format is a JSON with the following data: { "auth_type": "basic", "username": "session_id", "access_key": "somepassword" }.
1635  {
1636  return getVariableLengthField(
1637  credentialsAccess(),
1638  *this);
1639  }
1640 
1641  /// Credentials to identify/authenticate the client. The format is a JSON with the following data: { "auth_type": "basic", "username": "session_id", "access_key": "somepassword" }.
1642  ThisType& setCredentials(StrRef value)
1643  {
1644  setVariableLengthField(
1645  credentialsAccess(),
1646  value,
1647  *this);
1648 
1649  return *this;
1650  }
1651 
1652  /// Minimal size of message body in bytes.
1655  static
1656  BlockLength
1660  {
1661  return
1662  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
1663  42;
1664  }
1665 
1666  /// Size of message body in bytes.
1669  static
1670  BlockLength
1674  {
1675  return
1676  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
1677  minimalBlockLength(version);
1678  }
1679 
1680  /// Minimal variable fields size (when variable-length fields are empty).
1684  static
1685  MessageSize
1688  {
1689  return
1690  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
1691  static_cast<MessageSize>(CredentialsEncoding::Size);
1692  }
1693 
1694  /// Maximal message size.
1698  static UInt64 getMaxMessageSize(UInt8)
1700  {
1701  return
1703  }
1704 
1705  /// Reset all variable-length fields if any.
1708  {
1709  setCredentialsToNull();
1710  return *this;
1711  }
1712 
1713  /// Reset all variable-length and optional fields if any.
1714  ThisType& reset()
1716  {
1717  resetVariableFields();
1718  return *this;
1719  }
1720 
1721  /// \return class name.
1725  static const Char* className()
1726  {
1727  return "Establish4";
1728  }
1729 
1730  /// FIX message type.
1734  static StrRef fixType()
1736  {
1737  return constructStrRef("Establish4");
1738  }
1739 
1740  /// \return a human-readable presentation.
1742  std::string toString() const;
1743 
1744  /// \return the end of the message.
1746  const void* tail() const
1748  {
1749  return
1750  toOpaquePtr(
1751  (credentials().end()));
1752  }
1753 
1754  /// \return the size occupied by the message.
1758  {
1759  return
1760  SbeMessage::calculateBinarySize(tail());
1761  }
1762 
1763 private:
1764  void checkLength(
1765  EncodedLength length, SchemaVersion version) const
1766  {
1767  const EncodedLength minimalRequiredLength =
1768  minimalBlockLength(version) +
1769  MessageHeader::Size +
1770  getMinimalVariableFieldsSize(version);
1771 
1772  checkBinaryLength(
1773  *this, length, minimalRequiredLength);
1774  }
1775 
1776  /// Checks variable fields consistency.
1777  void checkVarLenFields() const
1778  {
1779  variableLengthFields().
1780  checkTail<CredentialsEncoding>();
1781  }
1782 
1783  void checkCompatibility() const
1784  {
1785  assert(TemplateId == templateId());
1786 
1787  checkSchema<Schema>(schemaId(), version());
1788  checkLength(bufferSize(), version());
1789  checkVarLenFields();
1790  }
1791 
1792  /// Access helper.
1793  struct credentialsAccess
1794  {
1795  CredentialsEncoding& operator()(const Establish4& obj) const
1797  {
1798  return obj.
1799  variableLengthFields().
1800  head<CredentialsEncoding>();
1801  }
1802  };
1803 
1804  /// Reset the field.
1805  /// All the following data will be invalidated.
1806  ThisType& setCredentialsToNull()
1808  {
1809  setVariableLengthFieldToNull(
1810  credentialsAccess(),
1811  *this);
1812 
1813  return *this;
1814  }
1815 };
1816 
1817 /// The EstablishmentAck message is sent when an Establish message is accepted by B3. EstablishmentAck message contains next sequence number. At the start of a session, default value is 1 (one).
1820 : SbeMessage
1821 {
1822  /// Used template schema.
1824 
1825  /// This type alias.
1827 
1828  /// Message template ID from SBE schema.
1829  enum { TemplateId = 5 };
1830 
1831  /// Initializes a blank instance.
1833 
1834  /// Initializes an instance over the given memory block.
1836  void* data,
1837  EncodedLength length,
1838  SchemaVersion version = Schema::Version)
1839  : SbeMessage(data, length, version)
1840  {
1841  checkVersion<Schema>(version);
1842  checkLength(length, version);
1843  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1844  reset();
1845  }
1846 
1847  /// Initializes an instance over the given memory block
1848  /// With no variable-length fields initialization
1849  /// It is assumed that the user does such an initialization manually.
1851  void* data,
1852  EncodedLength length,
1853  NoFieldsInit,
1854  SchemaVersion version = Schema::Version)
1855  : SbeMessage(data, length, version)
1856  {
1857  checkVersion<Schema>(version);
1858  checkLength(length, version);
1859  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1860  resetVariableFields();
1861  }
1862 
1863  /// Creates an instance over the given memory block.
1865  void* data,
1866  EncodedLength length,
1867  NoInit)
1868  : SbeMessage(data, length)
1869  {
1870  checkCompatibility();
1871  }
1872 
1873  /// Creates an instance over the given SBE message.
1874  explicit
1876  const SbeMessage& message)
1877  : SbeMessage(message)
1878  {
1879  assert(message.valid());
1880 
1881  checkCompatibility();
1882  }
1883 
1884  /// Creates an instance over the given memory block.
1885  /// Performs no checks.
1887  void* data,
1888  EncodedLength length,
1889  NoInit,
1890  NoCheck)
1892  : SbeMessage(data, length, NoCheck())
1893  {
1894  assert(schemaId() == Schema::Id);
1895  assert(version() >= Schema::MinimalVersion);
1896  assert(TemplateId == templateId());
1897  }
1898 
1899  /// Message type = EstablishAck.
1904  {
1905  return MessageType::EstablishAck;
1906  }
1907 
1908  /// Message type = EstablishAck.
1909 
1910  /// Client connection identification on the gateway assigned
1911  /// by B3.
1915  {
1917 
1918  return ordinary<SessionID>(offset);
1919  }
1920 
1921  /// Client connection identification on the gateway assigned
1922  /// by B3.
1923  ThisType& setSessionId(SessionID value)
1925  {
1927 
1928  setOrdinary(offset, value);
1929  return *this;
1930  }
1931 
1932  /// Session version identification: unique identification of a
1933  /// sequence of messages to be transmitted to/from B3´s
1934  /// gateways associated with given SessionId. Need to be
1935  /// incremented each time Negotiate message is sent to
1936  /// gateway.
1940  {
1942 
1943  return ordinary<SessionVerID>(offset);
1944  }
1945 
1946  /// Session version identification: unique identification of a
1947  /// sequence of messages to be transmitted to/from B3´s
1948  /// gateways associated with given SessionId. Need to be
1949  /// incremented each time Negotiate message is sent to
1950  /// gateway.
1953  {
1955 
1956  setOrdinary(offset, value);
1957  return *this;
1958  }
1959 
1960  /// Matches Negotiate timestamp.
1964  {
1966 
1967  return ordinary<UTCTimestampNanos>(offset);
1968  }
1969 
1970  /// Matches Negotiate timestamp.
1973  {
1975 
1976  setOrdinary(offset, value);
1977  return *this;
1978  }
1979 
1980  /// Longest time in milliseconds the initiator should remain
1981  /// silent before sending Sequence message.
1985  {
1987 
1988  return ordinary<DeltaInMillis>(offset);
1989  }
1990 
1991  /// Longest time in milliseconds the initiator should remain
1992  /// silent before sending Sequence message.
1995  {
1997 
1998  setOrdinary(offset, value);
1999  return *this;
2000  }
2001 
2002  /// The next application sequence number to be produced by the
2003  /// gateway.
2007  {
2009 
2010  return ordinary<SeqNum>(offset);
2011  }
2012 
2013  /// The next application sequence number to be produced by the
2014  /// gateway.
2015  ThisType& setNextSeqNo(SeqNum value)
2017  {
2019 
2020  setOrdinary(offset, value);
2021  return *this;
2022  }
2023 
2024  /// Indicates the application sequence number of the last
2025  /// application message received by the server from the
2026  /// client. At the start of a session, default value is 0
2027  /// (zero).
2031  {
2033 
2034  return ordinary<SeqNum>(offset);
2035  }
2036 
2037  /// Indicates the application sequence number of the last
2038  /// application message received by the server from the
2039  /// client. At the start of a session, default value is 0
2040  /// (zero).
2041  ThisType& setLastIncomingSeqNo(SeqNum value)
2043  {
2045 
2046  setOrdinary(offset, value);
2047  return *this;
2048  }
2049 
2050  /// Minimal size of message body in bytes.
2053  static
2054  BlockLength
2058  {
2059  return
2060  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2061  36;
2062  }
2063 
2064  /// Size of message body in bytes.
2069  {
2070  return
2071  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2072  minimalBlockLength(version);
2073  }
2074 
2075  /// Minimal variable fields size (when variable-length fields are empty).
2079  static
2080  MessageSize
2083  {
2084  return
2085  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2086  0;
2087  }
2088 
2089  /// Maximal message size.
2093  static UInt64 getMaxMessageSize(UInt8)
2095  {
2096  return
2097  static_cast<UInt64>(MessageHeaderBuilder::Size) +
2098  blockLength(Schema::Version);
2099  }
2100 
2101  /// Reset all variable-length fields if any.
2104  {
2105  return *this;
2106  }
2107 
2108  /// Reset all variable-length and optional fields if any.
2109  ThisType& reset()
2111  {
2112  resetVariableFields();
2113  return *this;
2114  }
2115 
2116  /// \return class name.
2120  static const Char* className()
2121  {
2122  return "EstablishAck5";
2123  }
2124 
2125  /// FIX message type.
2129  static StrRef fixType()
2131  {
2132  return constructStrRef("EstablishAck5");
2133  }
2134 
2135  /// \return a human-readable presentation.
2137  std::string toString() const;
2138 
2139  /// \return the end of the message.
2141  const void* tail() const
2143  {
2144  return
2145  toOpaquePtr(
2146  advanceByBytes(
2147  binary(),
2148  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
2149  MessageHeader::Size));
2150  }
2151 
2152  /// \return the size occupied by the message.
2156  {
2157  return
2158  SbeMessage::calculateBinarySize(tail());
2159  }
2160 
2161 private:
2162  void checkLength(
2163  EncodedLength length, SchemaVersion version) const
2164  {
2165  const EncodedLength minimalRequiredLength =
2166  minimalBlockLength(version) +
2167  MessageHeader::Size +
2168  getMinimalVariableFieldsSize(version);
2169 
2170  checkBinaryLength(
2171  *this, length, minimalRequiredLength);
2172  }
2173 
2174  void checkCompatibility() const
2175  {
2176  assert(TemplateId == templateId());
2177 
2178  checkSchema<Schema>(schemaId(), version());
2179  checkLength(bufferSize(), version());
2180  }
2181 };
2182 
2183 /// EstablishmentReject message is sent when an Establish message is rejected by B3 informing the reason of rejection.
2186 : SbeMessage
2187 {
2188  /// Used template schema.
2190 
2191  /// This type alias.
2193 
2194  /// Message template ID from SBE schema.
2195  enum { TemplateId = 6 };
2196 
2197  /// Initializes a blank instance.
2199 
2200  /// Initializes an instance over the given memory block.
2202  void* data,
2203  EncodedLength length,
2204  SchemaVersion version = Schema::Version)
2205  : SbeMessage(data, length, version)
2206  {
2207  checkVersion<Schema>(version);
2208  checkLength(length, version);
2209  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2210  reset();
2211  }
2212 
2213  /// Initializes an instance over the given memory block
2214  /// With no variable-length fields initialization
2215  /// It is assumed that the user does such an initialization manually.
2217  void* data,
2218  EncodedLength length,
2219  NoFieldsInit,
2220  SchemaVersion version = Schema::Version)
2221  : SbeMessage(data, length, version)
2222  {
2223  checkVersion<Schema>(version);
2224  checkLength(length, version);
2225  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2226  resetVariableFields();
2227  }
2228 
2229  /// Creates an instance over the given memory block.
2231  void* data,
2232  EncodedLength length,
2233  NoInit)
2234  : SbeMessage(data, length)
2235  {
2236  checkCompatibility();
2237  }
2238 
2239  /// Creates an instance over the given SBE message.
2240  explicit
2242  const SbeMessage& message)
2243  : SbeMessage(message)
2244  {
2245  assert(message.valid());
2246 
2247  checkCompatibility();
2248  }
2249 
2250  /// Creates an instance over the given memory block.
2251  /// Performs no checks.
2253  void* data,
2254  EncodedLength length,
2255  NoInit,
2256  NoCheck)
2258  : SbeMessage(data, length, NoCheck())
2259  {
2260  assert(schemaId() == Schema::Id);
2261  assert(version() >= Schema::MinimalVersion);
2262  assert(TemplateId == templateId());
2263  }
2264 
2265  /// Message type = EstablishReject.
2270  {
2271  return MessageType::EstablishReject;
2272  }
2273 
2274  /// Message type = EstablishReject.
2275 
2276  /// Client connection identification on the gateway assigned
2277  /// by B3.
2281  {
2283 
2284  return ordinary<SessionID>(offset);
2285  }
2286 
2287  /// Client connection identification on the gateway assigned
2288  /// by B3.
2289  ThisType& setSessionId(SessionID value)
2291  {
2293 
2294  setOrdinary(offset, value);
2295  return *this;
2296  }
2297 
2298  /// Session version identification: unique identification of a
2299  /// sequence of messages to be transmitted to/from B3´s
2300  /// gateways associated with given SessionId. Need to be
2301  /// incremented each time Negotiate message is sent to
2302  /// gateway.
2306  {
2308 
2309  return ordinary<SessionVerID>(offset);
2310  }
2311 
2312  /// Session version identification: unique identification of a
2313  /// sequence of messages to be transmitted to/from B3´s
2314  /// gateways associated with given SessionId. Need to be
2315  /// incremented each time Negotiate message is sent to
2316  /// gateway.
2319  {
2321 
2322  setOrdinary(offset, value);
2323  return *this;
2324  }
2325 
2326  /// Matches Negotiate timestamp.
2330  {
2332 
2333  return ordinary<UTCTimestampNanos>(offset);
2334  }
2335 
2336  /// Matches Negotiate timestamp.
2339  {
2341 
2342  setOrdinary(offset, value);
2343  return *this;
2344  }
2345 
2346  /// Identifies the code of reject establishment.
2351  {
2353 
2354  return enumeration<EstablishRejectCode>(offset);
2355  }
2356 
2357  /// Identifies the code of reject establishment.
2358  ThisType&
2362  {
2364 
2365  setEnumeration<EstablishRejectCode>(offset, value);
2366  return *this;
2367  }
2368 
2369  /// If establishmentRejectCode =
2370  /// EstablishRejectCode.INVALID_NEXTSEQNO, indicates the
2371  /// application sequence number of the last application
2372  /// message received by the server from the client. At the
2373  /// start of a session, default value is 0 (zero).
2377  {
2379 
2380  return ordinary(value, offset, NullSeqNumOptional());
2381  }
2382 
2383  /// If establishmentRejectCode =
2384  /// EstablishRejectCode.INVALID_NEXTSEQNO, indicates the
2385  /// application sequence number of the last application
2386  /// message received by the server from the client. At the
2387  /// start of a session, default value is 0 (zero).
2390  {
2392 
2393  setOrdinary(offset, value);
2394  return *this;
2395  }
2396 
2399  {
2401 
2402  setOrdinary(offset, NullSeqNumOptional());
2403  return *this;
2404  }
2405 
2406  /// Minimal size of message body in bytes.
2409  static
2410  BlockLength
2414  {
2415  return
2416  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2417  26;
2418  }
2419 
2420  /// Size of message body in bytes.
2423  static
2424  BlockLength
2428  {
2429  return
2430  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2431  minimalBlockLength(version);
2432  }
2433 
2434  /// Minimal variable fields size (when variable-length fields are empty).
2438  static
2439  MessageSize
2442  {
2443  return
2444  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2445  0;
2446  }
2447 
2448  /// Maximal message size.
2452  static UInt64 getMaxMessageSize(UInt8)
2454  {
2455  return
2456  static_cast<UInt64>(MessageHeaderBuilder::Size) +
2457  blockLength(Schema::Version);
2458  }
2459 
2460  /// Reset all variable-length fields if any.
2463  {
2464  return *this;
2465  }
2466 
2467  /// Reset all variable-length and optional fields if any.
2468  ThisType& reset()
2470  {
2471  setLastIncomingSeqNoToNull();
2472 
2473  resetVariableFields();
2474  return *this;
2475  }
2476 
2477  /// \return class name.
2481  static const Char* className()
2482  {
2483  return "EstablishReject6";
2484  }
2485 
2486  /// FIX message type.
2490  static StrRef fixType()
2492  {
2493  return constructStrRef("EstablishReject6");
2494  }
2495 
2496  /// \return a human-readable presentation.
2498  std::string toString() const;
2499 
2500  /// \return the end of the message.
2502  const void* tail() const
2504  {
2505  return
2506  toOpaquePtr(
2507  advanceByBytes(
2508  binary(),
2509  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
2510  MessageHeader::Size));
2511  }
2512 
2513  /// \return the size occupied by the message.
2517  {
2518  return
2519  SbeMessage::calculateBinarySize(tail());
2520  }
2521 
2522 private:
2523  void checkLength(
2524  EncodedLength length, SchemaVersion version) const
2525  {
2526  const EncodedLength minimalRequiredLength =
2527  minimalBlockLength(version) +
2528  MessageHeader::Size +
2529  getMinimalVariableFieldsSize(version);
2530 
2531  checkBinaryLength(
2532  *this, length, minimalRequiredLength);
2533  }
2534 
2535  void checkCompatibility() const
2536  {
2537  assert(TemplateId == templateId());
2538 
2539  checkSchema<Schema>(schemaId(), version());
2540  checkLength(bufferSize(), version());
2541  }
2542 };
2543 
2544 /// Terminate message is sent to indicate that the sender is going to disconnect the TCP socket connection.
2546 Terminate7
2547 : SbeMessage
2548 {
2549  /// Used template schema.
2551 
2552  /// This type alias.
2554 
2555  /// Message template ID from SBE schema.
2556  enum { TemplateId = 7 };
2557 
2558  /// Initializes a blank instance.
2560 
2561  /// Initializes an instance over the given memory block.
2563  void* data,
2564  EncodedLength length,
2565  SchemaVersion version = Schema::Version)
2566  : SbeMessage(data, length, version)
2567  {
2568  checkVersion<Schema>(version);
2569  checkLength(length, version);
2570  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2571  reset();
2572  }
2573 
2574  /// Initializes an instance over the given memory block
2575  /// With no variable-length fields initialization
2576  /// It is assumed that the user does such an initialization manually.
2578  void* data,
2579  EncodedLength length,
2580  NoFieldsInit,
2581  SchemaVersion version = Schema::Version)
2582  : SbeMessage(data, length, version)
2583  {
2584  checkVersion<Schema>(version);
2585  checkLength(length, version);
2586  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2587  resetVariableFields();
2588  }
2589 
2590  /// Creates an instance over the given memory block.
2592  void* data,
2593  EncodedLength length,
2594  NoInit)
2595  : SbeMessage(data, length)
2596  {
2597  checkCompatibility();
2598  }
2599 
2600  /// Creates an instance over the given SBE message.
2601  explicit
2603  const SbeMessage& message)
2604  : SbeMessage(message)
2605  {
2606  assert(message.valid());
2607 
2608  checkCompatibility();
2609  }
2610 
2611  /// Creates an instance over the given memory block.
2612  /// Performs no checks.
2614  void* data,
2615  EncodedLength length,
2616  NoInit,
2617  NoCheck)
2619  : SbeMessage(data, length, NoCheck())
2620  {
2621  assert(schemaId() == Schema::Id);
2622  assert(version() >= Schema::MinimalVersion);
2623  assert(TemplateId == templateId());
2624  }
2625 
2626  /// Message type = Terminate.
2631  {
2632  return MessageType::Terminate;
2633  }
2634 
2635  /// Message type = Terminate.
2636 
2637  /// Client connection identification on the gateway assigned
2638  /// by B3.
2642  {
2644 
2645  return ordinary<SessionID>(offset);
2646  }
2647 
2648  /// Client connection identification on the gateway assigned
2649  /// by B3.
2650  ThisType& setSessionId(SessionID value)
2652  {
2654 
2655  setOrdinary(offset, value);
2656  return *this;
2657  }
2658 
2659  /// Session version identification: unique identification of a
2660  /// sequence of messages to be transmitted to/from B3´s
2661  /// gateways associated with given SessionId. Need to be
2662  /// incremented each time Negotiate message is sent to
2663  /// gateway.
2667  {
2669 
2670  return ordinary<SessionVerID>(offset);
2671  }
2672 
2673  /// Session version identification: unique identification of a
2674  /// sequence of messages to be transmitted to/from B3´s
2675  /// gateways associated with given SessionId. Need to be
2676  /// incremented each time Negotiate message is sent to
2677  /// gateway.
2680  {
2682 
2683  setOrdinary(offset, value);
2684  return *this;
2685  }
2686 
2687  /// Identifies the code of termination.
2691  {
2693 
2694  return enumeration<TerminationCode>(offset);
2695  }
2696 
2697  /// Identifies the code of termination.
2698  ThisType&
2700  TerminationCode::Enum value)
2702  {
2704 
2705  setEnumeration<TerminationCode>(offset, value);
2706  return *this;
2707  }
2708 
2709  /// Minimal size of message body in bytes.
2712  static
2713  BlockLength
2717  {
2718  return
2719  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2720  13;
2721  }
2722 
2723  /// Size of message body in bytes.
2728  {
2729  return
2730  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2731  minimalBlockLength(version);
2732  }
2733 
2734  /// Minimal variable fields size (when variable-length fields are empty).
2738  static
2739  MessageSize
2742  {
2743  return
2744  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2745  0;
2746  }
2747 
2748  /// Maximal message size.
2752  static UInt64 getMaxMessageSize(UInt8)
2754  {
2755  return
2756  static_cast<UInt64>(MessageHeaderBuilder::Size) +
2757  blockLength(Schema::Version);
2758  }
2759 
2760  /// Reset all variable-length fields if any.
2763  {
2764  return *this;
2765  }
2766 
2767  /// Reset all variable-length and optional fields if any.
2768  ThisType& reset()
2770  {
2771  resetVariableFields();
2772  return *this;
2773  }
2774 
2775  /// \return class name.
2779  static const Char* className()
2780  {
2781  return "Terminate7";
2782  }
2783 
2784  /// FIX message type.
2788  static StrRef fixType()
2790  {
2791  return constructStrRef("Terminate7");
2792  }
2793 
2794  /// \return a human-readable presentation.
2796  std::string toString() const;
2797 
2798  /// \return the end of the message.
2800  const void* tail() const
2802  {
2803  return
2804  toOpaquePtr(
2805  advanceByBytes(
2806  binary(),
2807  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
2808  MessageHeader::Size));
2809  }
2810 
2811  /// \return the size occupied by the message.
2815  {
2816  return
2817  SbeMessage::calculateBinarySize(tail());
2818  }
2819 
2820 private:
2821  void checkLength(
2822  EncodedLength length, SchemaVersion version) const
2823  {
2824  const EncodedLength minimalRequiredLength =
2825  minimalBlockLength(version) +
2826  MessageHeader::Size +
2827  getMinimalVariableFieldsSize(version);
2828 
2829  checkBinaryLength(
2830  *this, length, minimalRequiredLength);
2831  }
2832 
2833  void checkCompatibility() const
2834  {
2835  assert(TemplateId == templateId());
2836 
2837  checkSchema<Schema>(schemaId(), version());
2838  checkLength(bufferSize(), version());
2839  }
2840 };
2841 
2842 /// NotApplied message is sent when B3 detects messages that already been sent (concept of idempotence) or an invalid message format from the client.
2845 : SbeMessage
2846 {
2847  /// Used template schema.
2849 
2850  /// This type alias.
2852 
2853  /// Message template ID from SBE schema.
2854  enum { TemplateId = 8 };
2855 
2856  /// Initializes a blank instance.
2858 
2859  /// Initializes an instance over the given memory block.
2861  void* data,
2862  EncodedLength length,
2863  SchemaVersion version = Schema::Version)
2864  : SbeMessage(data, length, version)
2865  {
2866  checkVersion<Schema>(version);
2867  checkLength(length, version);
2868  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2869  reset();
2870  }
2871 
2872  /// Initializes an instance over the given memory block
2873  /// With no variable-length fields initialization
2874  /// It is assumed that the user does such an initialization manually.
2876  void* data,
2877  EncodedLength length,
2878  NoFieldsInit,
2879  SchemaVersion version = Schema::Version)
2880  : SbeMessage(data, length, version)
2881  {
2882  checkVersion<Schema>(version);
2883  checkLength(length, version);
2884  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2885  resetVariableFields();
2886  }
2887 
2888  /// Creates an instance over the given memory block.
2890  void* data,
2891  EncodedLength length,
2892  NoInit)
2893  : SbeMessage(data, length)
2894  {
2895  checkCompatibility();
2896  }
2897 
2898  /// Creates an instance over the given SBE message.
2899  explicit
2901  const SbeMessage& message)
2902  : SbeMessage(message)
2903  {
2904  assert(message.valid());
2905 
2906  checkCompatibility();
2907  }
2908 
2909  /// Creates an instance over the given memory block.
2910  /// Performs no checks.
2912  void* data,
2913  EncodedLength length,
2914  NoInit,
2915  NoCheck)
2917  : SbeMessage(data, length, NoCheck())
2918  {
2919  assert(schemaId() == Schema::Id);
2920  assert(version() >= Schema::MinimalVersion);
2921  assert(TemplateId == templateId());
2922  }
2923 
2924  /// Message type = NotApplied.
2929  {
2930  return MessageType::NotApplied;
2931  }
2932 
2933  /// Message type = NotApplied.
2934 
2935  /// The first applied sequence number.
2939  {
2941 
2942  return ordinary<SeqNum>(offset);
2943  }
2944 
2945  /// The first applied sequence number.
2946  ThisType& setFromSeqNo(SeqNum value)
2948  {
2950 
2951  setOrdinary(offset, value);
2952  return *this;
2953  }
2954 
2955  /// How many messages haven´t been applied?.
2959  {
2961 
2962  return ordinary<MessageCounter>(offset);
2963  }
2964 
2965  /// How many messages haven´t been applied?.
2966  ThisType& setCount(MessageCounter value)
2968  {
2970 
2971  setOrdinary(offset, value);
2972  return *this;
2973  }
2974 
2975  /// Minimal size of message body in bytes.
2978  static
2979  BlockLength
2983  {
2984  return
2985  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2986  8;
2987  }
2988 
2989  /// Size of message body in bytes.
2994  {
2995  return
2996  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
2997  minimalBlockLength(version);
2998  }
2999 
3000  /// Minimal variable fields size (when variable-length fields are empty).
3004  static
3005  MessageSize
3008  {
3009  return
3010  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3011  0;
3012  }
3013 
3014  /// Maximal message size.
3018  static UInt64 getMaxMessageSize(UInt8)
3020  {
3021  return
3022  static_cast<UInt64>(MessageHeaderBuilder::Size) +
3023  blockLength(Schema::Version);
3024  }
3025 
3026  /// Reset all variable-length fields if any.
3029  {
3030  return *this;
3031  }
3032 
3033  /// Reset all variable-length and optional fields if any.
3034  ThisType& reset()
3036  {
3037  resetVariableFields();
3038  return *this;
3039  }
3040 
3041  /// \return class name.
3045  static const Char* className()
3046  {
3047  return "NotApplied8";
3048  }
3049 
3050  /// FIX message type.
3054  static StrRef fixType()
3056  {
3057  return constructStrRef("NotApplied8");
3058  }
3059 
3060  /// \return a human-readable presentation.
3062  std::string toString() const;
3063 
3064  /// \return the end of the message.
3066  const void* tail() const
3068  {
3069  return
3070  toOpaquePtr(
3071  advanceByBytes(
3072  binary(),
3073  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
3074  MessageHeader::Size));
3075  }
3076 
3077  /// \return the size occupied by the message.
3081  {
3082  return
3083  SbeMessage::calculateBinarySize(tail());
3084  }
3085 
3086 private:
3087  void checkLength(
3088  EncodedLength length, SchemaVersion version) const
3089  {
3090  const EncodedLength minimalRequiredLength =
3091  minimalBlockLength(version) +
3092  MessageHeader::Size +
3093  getMinimalVariableFieldsSize(version);
3094 
3095  checkBinaryLength(
3096  *this, length, minimalRequiredLength);
3097  }
3098 
3099  void checkCompatibility() const
3100  {
3101  assert(TemplateId == templateId());
3102 
3103  checkSchema<Schema>(schemaId(), version());
3104  checkLength(bufferSize(), version());
3105  }
3106 };
3107 
3108 /// Sequence message specifies the sequence number of the next business message both: Recoverable (B3 to client) and Idempotent (client to B3) flows. It is also used as heartbeat.
3110 Sequence9
3111 : SbeMessage
3112 {
3113  /// Used template schema.
3115 
3116  /// This type alias.
3118 
3119  /// Message template ID from SBE schema.
3120  enum { TemplateId = 9 };
3121 
3122  /// Initializes a blank instance.
3124 
3125  /// Initializes an instance over the given memory block.
3127  void* data,
3128  EncodedLength length,
3129  SchemaVersion version = Schema::Version)
3130  : SbeMessage(data, length, version)
3131  {
3132  checkVersion<Schema>(version);
3133  checkLength(length, version);
3134  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3135  reset();
3136  }
3137 
3138  /// Initializes an instance over the given memory block
3139  /// With no variable-length fields initialization
3140  /// It is assumed that the user does such an initialization manually.
3142  void* data,
3143  EncodedLength length,
3144  NoFieldsInit,
3145  SchemaVersion version = Schema::Version)
3146  : SbeMessage(data, length, version)
3147  {
3148  checkVersion<Schema>(version);
3149  checkLength(length, version);
3150  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3151  resetVariableFields();
3152  }
3153 
3154  /// Creates an instance over the given memory block.
3156  void* data,
3157  EncodedLength length,
3158  NoInit)
3159  : SbeMessage(data, length)
3160  {
3161  checkCompatibility();
3162  }
3163 
3164  /// Creates an instance over the given SBE message.
3165  explicit
3167  const SbeMessage& message)
3168  : SbeMessage(message)
3169  {
3170  assert(message.valid());
3171 
3172  checkCompatibility();
3173  }
3174 
3175  /// Creates an instance over the given memory block.
3176  /// Performs no checks.
3178  void* data,
3179  EncodedLength length,
3180  NoInit,
3181  NoCheck)
3183  : SbeMessage(data, length, NoCheck())
3184  {
3185  assert(schemaId() == Schema::Id);
3186  assert(version() >= Schema::MinimalVersion);
3187  assert(TemplateId == templateId());
3188  }
3189 
3190  /// Message type = Sequence.
3195  {
3196  return MessageType::Sequence;
3197  }
3198 
3199  /// Message type = Sequence.
3200 
3201  /// The next application sequence number to be produced by the
3202  /// client.
3206  {
3208 
3209  return ordinary<SeqNum>(offset);
3210  }
3211 
3212  /// The next application sequence number to be produced by the
3213  /// client.
3214  ThisType& setNextSeqNo(SeqNum value)
3216  {
3218 
3219  setOrdinary(offset, value);
3220  return *this;
3221  }
3222 
3223  /// Minimal size of message body in bytes.
3226  static
3227  BlockLength
3231  {
3232  return
3233  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3234  4;
3235  }
3236 
3237  /// Size of message body in bytes.
3242  {
3243  return
3244  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3245  minimalBlockLength(version);
3246  }
3247 
3248  /// Minimal variable fields size (when variable-length fields are empty).
3252  static
3253  MessageSize
3256  {
3257  return
3258  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3259  0;
3260  }
3261 
3262  /// Maximal message size.
3266  static UInt64 getMaxMessageSize(UInt8)
3268  {
3269  return
3270  static_cast<UInt64>(MessageHeaderBuilder::Size) +
3271  blockLength(Schema::Version);
3272  }
3273 
3274  /// Reset all variable-length fields if any.
3277  {
3278  return *this;
3279  }
3280 
3281  /// Reset all variable-length and optional fields if any.
3282  ThisType& reset()
3284  {
3285  resetVariableFields();
3286  return *this;
3287  }
3288 
3289  /// \return class name.
3293  static const Char* className()
3294  {
3295  return "Sequence9";
3296  }
3297 
3298  /// FIX message type.
3302  static StrRef fixType()
3304  {
3305  return constructStrRef("Sequence9");
3306  }
3307 
3308  /// \return a human-readable presentation.
3310  std::string toString() const;
3311 
3312  /// \return the end of the message.
3314  const void* tail() const
3316  {
3317  return
3318  toOpaquePtr(
3319  advanceByBytes(
3320  binary(),
3321  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
3322  MessageHeader::Size));
3323  }
3324 
3325  /// \return the size occupied by the message.
3329  {
3330  return
3331  SbeMessage::calculateBinarySize(tail());
3332  }
3333 
3334 private:
3335  void checkLength(
3336  EncodedLength length, SchemaVersion version) const
3337  {
3338  const EncodedLength minimalRequiredLength =
3339  minimalBlockLength(version) +
3340  MessageHeader::Size +
3341  getMinimalVariableFieldsSize(version);
3342 
3343  checkBinaryLength(
3344  *this, length, minimalRequiredLength);
3345  }
3346 
3347  void checkCompatibility() const
3348  {
3349  assert(TemplateId == templateId());
3350 
3351  checkSchema<Schema>(schemaId(), version());
3352  checkLength(bufferSize(), version());
3353  }
3354 };
3355 
3356 /// RetransmitRequest message is used for client to recover missed messages.
3359 : SbeMessage
3360 {
3361  /// Used template schema.
3363 
3364  /// This type alias.
3366 
3367  /// Message template ID from SBE schema.
3368  enum { TemplateId = 12 };
3369 
3370  /// Initializes a blank instance.
3372 
3373  /// Initializes an instance over the given memory block.
3375  void* data,
3376  EncodedLength length,
3377  SchemaVersion version = Schema::Version)
3378  : SbeMessage(data, length, version)
3379  {
3380  checkVersion<Schema>(version);
3381  checkLength(length, version);
3382  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3383  reset();
3384  }
3385 
3386  /// Initializes an instance over the given memory block
3387  /// With no variable-length fields initialization
3388  /// It is assumed that the user does such an initialization manually.
3390  void* data,
3391  EncodedLength length,
3392  NoFieldsInit,
3393  SchemaVersion version = Schema::Version)
3394  : SbeMessage(data, length, version)
3395  {
3396  checkVersion<Schema>(version);
3397  checkLength(length, version);
3398  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3399  resetVariableFields();
3400  }
3401 
3402  /// Creates an instance over the given memory block.
3404  void* data,
3405  EncodedLength length,
3406  NoInit)
3407  : SbeMessage(data, length)
3408  {
3409  checkCompatibility();
3410  }
3411 
3412  /// Creates an instance over the given SBE message.
3413  explicit
3415  const SbeMessage& message)
3416  : SbeMessage(message)
3417  {
3418  assert(message.valid());
3419 
3420  checkCompatibility();
3421  }
3422 
3423  /// Creates an instance over the given memory block.
3424  /// Performs no checks.
3426  void* data,
3427  EncodedLength length,
3428  NoInit,
3429  NoCheck)
3431  : SbeMessage(data, length, NoCheck())
3432  {
3433  assert(schemaId() == Schema::Id);
3434  assert(version() >= Schema::MinimalVersion);
3435  assert(TemplateId == templateId());
3436  }
3437 
3438  /// Message type = RetransmitRequest.
3443  {
3444  return MessageType::RetransmitRequest;
3445  }
3446 
3447  /// Message type = RetransmitRequest.
3448 
3449  /// Client connection identification on the gateway assigned
3450  /// by B3.
3454  {
3456 
3457  return ordinary<SessionID>(offset);
3458  }
3459 
3460  /// Client connection identification on the gateway assigned
3461  /// by B3.
3462  ThisType& setSessionId(SessionID value)
3464  {
3466 
3467  setOrdinary(offset, value);
3468  return *this;
3469  }
3470 
3471  /// Time of request. Sent in number of nanoseconds since Unix
3472  /// epoch.
3476  {
3478 
3479  return ordinary<UTCTimestampNanos>(offset);
3480  }
3481 
3482  /// Time of request. Sent in number of nanoseconds since Unix
3483  /// epoch.
3486  {
3488 
3489  setOrdinary(offset, value);
3490  return *this;
3491  }
3492 
3493  /// The first applied sequence number.
3497  {
3499 
3500  return ordinary<SeqNum>(offset);
3501  }
3502 
3503  /// The first applied sequence number.
3504  ThisType& setFromSeqNo(SeqNum value)
3506  {
3508 
3509  setOrdinary(offset, value);
3510  return *this;
3511  }
3512 
3513  /// Maximum number of messages to be retransmitted. Range is 1
3514  /// to 1000 (inclusive).
3518  {
3520 
3521  return ordinary<MessageCounter>(offset);
3522  }
3523 
3524  /// Maximum number of messages to be retransmitted. Range is 1
3525  /// to 1000 (inclusive).
3526  ThisType& setCount(MessageCounter value)
3528  {
3530 
3531  setOrdinary(offset, value);
3532  return *this;
3533  }
3534 
3535  /// Minimal size of message body in bytes.
3538  static
3539  BlockLength
3543  {
3544  return
3545  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3546  20;
3547  }
3548 
3549  /// Size of message body in bytes.
3554  {
3555  return
3556  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3557  minimalBlockLength(version);
3558  }
3559 
3560  /// Minimal variable fields size (when variable-length fields are empty).
3564  static
3565  MessageSize
3568  {
3569  return
3570  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3571  0;
3572  }
3573 
3574  /// Maximal message size.
3578  static UInt64 getMaxMessageSize(UInt8)
3580  {
3581  return
3582  static_cast<UInt64>(MessageHeaderBuilder::Size) +
3583  blockLength(Schema::Version);
3584  }
3585 
3586  /// Reset all variable-length fields if any.
3589  {
3590  return *this;
3591  }
3592 
3593  /// Reset all variable-length and optional fields if any.
3594  ThisType& reset()
3596  {
3597  resetVariableFields();
3598  return *this;
3599  }
3600 
3601  /// \return class name.
3605  static const Char* className()
3606  {
3607  return "RetransmitRequest12";
3608  }
3609 
3610  /// FIX message type.
3614  static StrRef fixType()
3616  {
3617  return constructStrRef("RetransmitRequest12");
3618  }
3619 
3620  /// \return a human-readable presentation.
3622  std::string toString() const;
3623 
3624  /// \return the end of the message.
3626  const void* tail() const
3628  {
3629  return
3630  toOpaquePtr(
3631  advanceByBytes(
3632  binary(),
3633  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
3634  MessageHeader::Size));
3635  }
3636 
3637  /// \return the size occupied by the message.
3641  {
3642  return
3643  SbeMessage::calculateBinarySize(tail());
3644  }
3645 
3646 private:
3647  void checkLength(
3648  EncodedLength length, SchemaVersion version) const
3649  {
3650  const EncodedLength minimalRequiredLength =
3651  minimalBlockLength(version) +
3652  MessageHeader::Size +
3653  getMinimalVariableFieldsSize(version);
3654 
3655  checkBinaryLength(
3656  *this, length, minimalRequiredLength);
3657  }
3658 
3659  void checkCompatibility() const
3660  {
3661  assert(TemplateId == templateId());
3662 
3663  checkSchema<Schema>(schemaId(), version());
3664  checkLength(bufferSize(), version());
3665  }
3666 };
3667 
3668 /// Retransmission message is sent when a RetransmitRequest message from the client is accepted by B3.
3671 : SbeMessage
3672 {
3673  /// Used template schema.
3675 
3676  /// This type alias.
3678 
3679  /// Message template ID from SBE schema.
3680  enum { TemplateId = 13 };
3681 
3682  /// Initializes a blank instance.
3684 
3685  /// Initializes an instance over the given memory block.
3687  void* data,
3688  EncodedLength length,
3689  SchemaVersion version = Schema::Version)
3690  : SbeMessage(data, length, version)
3691  {
3692  checkVersion<Schema>(version);
3693  checkLength(length, version);
3694  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3695  reset();
3696  }
3697 
3698  /// Initializes an instance over the given memory block
3699  /// With no variable-length fields initialization
3700  /// It is assumed that the user does such an initialization manually.
3702  void* data,
3703  EncodedLength length,
3704  NoFieldsInit,
3705  SchemaVersion version = Schema::Version)
3706  : SbeMessage(data, length, version)
3707  {
3708  checkVersion<Schema>(version);
3709  checkLength(length, version);
3710  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3711  resetVariableFields();
3712  }
3713 
3714  /// Creates an instance over the given memory block.
3716  void* data,
3717  EncodedLength length,
3718  NoInit)
3719  : SbeMessage(data, length)
3720  {
3721  checkCompatibility();
3722  }
3723 
3724  /// Creates an instance over the given SBE message.
3725  explicit
3727  const SbeMessage& message)
3728  : SbeMessage(message)
3729  {
3730  assert(message.valid());
3731 
3732  checkCompatibility();
3733  }
3734 
3735  /// Creates an instance over the given memory block.
3736  /// Performs no checks.
3738  void* data,
3739  EncodedLength length,
3740  NoInit,
3741  NoCheck)
3743  : SbeMessage(data, length, NoCheck())
3744  {
3745  assert(schemaId() == Schema::Id);
3746  assert(version() >= Schema::MinimalVersion);
3747  assert(TemplateId == templateId());
3748  }
3749 
3750  /// Message type = Retransmission.
3755  {
3756  return MessageType::Retransmission;
3757  }
3758 
3759  /// Message type = Retransmission.
3760 
3761  /// Client connection identification on the gateway assigned
3762  /// by B3.
3766  {
3768 
3769  return ordinary<SessionID>(offset);
3770  }
3771 
3772  /// Client connection identification on the gateway assigned
3773  /// by B3.
3774  ThisType& setSessionId(SessionID value)
3776  {
3778 
3779  setOrdinary(offset, value);
3780  return *this;
3781  }
3782 
3783  /// Matches Negotiate timestamp.
3787  {
3789 
3790  return ordinary<UTCTimestampNanos>(offset);
3791  }
3792 
3793  /// Matches Negotiate timestamp.
3796  {
3798 
3799  setOrdinary(offset, value);
3800  return *this;
3801  }
3802 
3803  /// The sequence number of the first retransmitted message.
3807  {
3809 
3810  return ordinary<SeqNum>(offset);
3811  }
3812 
3813  /// The sequence number of the first retransmitted message.
3814  ThisType& setNextSeqNo(SeqNum value)
3816  {
3818 
3819  setOrdinary(offset, value);
3820  return *this;
3821  }
3822 
3823  /// Number of messages to be retransmitted.
3827  {
3829 
3830  return ordinary<MessageCounter>(offset);
3831  }
3832 
3833  /// Number of messages to be retransmitted.
3834  ThisType& setCount(MessageCounter value)
3836  {
3838 
3839  setOrdinary(offset, value);
3840  return *this;
3841  }
3842 
3843  /// Minimal size of message body in bytes.
3846  static
3847  BlockLength
3851  {
3852  return
3853  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3854  20;
3855  }
3856 
3857  /// Size of message body in bytes.
3862  {
3863  return
3864  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3865  minimalBlockLength(version);
3866  }
3867 
3868  /// Minimal variable fields size (when variable-length fields are empty).
3872  static
3873  MessageSize
3876  {
3877  return
3878  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
3879  0;
3880  }
3881 
3882  /// Maximal message size.
3886  static UInt64 getMaxMessageSize(UInt8)
3888  {
3889  return
3890  static_cast<UInt64>(MessageHeaderBuilder::Size) +
3891  blockLength(Schema::Version);
3892  }
3893 
3894  /// Reset all variable-length fields if any.
3897  {
3898  return *this;
3899  }
3900 
3901  /// Reset all variable-length and optional fields if any.
3902  ThisType& reset()
3904  {
3905  resetVariableFields();
3906  return *this;
3907  }
3908 
3909  /// \return class name.
3913  static const Char* className()
3914  {
3915  return "Retransmission13";
3916  }
3917 
3918  /// FIX message type.
3922  static StrRef fixType()
3924  {
3925  return constructStrRef("Retransmission13");
3926  }
3927 
3928  /// \return a human-readable presentation.
3930  std::string toString() const;
3931 
3932  /// \return the end of the message.
3934  const void* tail() const
3936  {
3937  return
3938  toOpaquePtr(
3939  advanceByBytes(
3940  binary(),
3941  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
3942  MessageHeader::Size));
3943  }
3944 
3945  /// \return the size occupied by the message.
3949  {
3950  return
3951  SbeMessage::calculateBinarySize(tail());
3952  }
3953 
3954 private:
3955  void checkLength(
3956  EncodedLength length, SchemaVersion version) const
3957  {
3958  const EncodedLength minimalRequiredLength =
3959  minimalBlockLength(version) +
3960  MessageHeader::Size +
3961  getMinimalVariableFieldsSize(version);
3962 
3963  checkBinaryLength(
3964  *this, length, minimalRequiredLength);
3965  }
3966 
3967  void checkCompatibility() const
3968  {
3969  assert(TemplateId == templateId());
3970 
3971  checkSchema<Schema>(schemaId(), version());
3972  checkLength(bufferSize(), version());
3973  }
3974 };
3975 
3976 /// RetransmitReject message is sent when a RetransmitRequest message is rejected by B3. More details are described in the Message Specification Guidelines document.
3979 : SbeMessage
3980 {
3981  /// Used template schema.
3983 
3984  /// This type alias.
3986 
3987  /// Message template ID from SBE schema.
3988  enum { TemplateId = 14 };
3989 
3990  /// Initializes a blank instance.
3992 
3993  /// Initializes an instance over the given memory block.
3995  void* data,
3996  EncodedLength length,
3997  SchemaVersion version = Schema::Version)
3998  : SbeMessage(data, length, version)
3999  {
4000  checkVersion<Schema>(version);
4001  checkLength(length, version);
4002  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4003  reset();
4004  }
4005 
4006  /// Initializes an instance over the given memory block
4007  /// With no variable-length fields initialization
4008  /// It is assumed that the user does such an initialization manually.
4010  void* data,
4011  EncodedLength length,
4012  NoFieldsInit,
4013  SchemaVersion version = Schema::Version)
4014  : SbeMessage(data, length, version)
4015  {
4016  checkVersion<Schema>(version);
4017  checkLength(length, version);
4018  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4019  resetVariableFields();
4020  }
4021 
4022  /// Creates an instance over the given memory block.
4024  void* data,
4025  EncodedLength length,
4026  NoInit)
4027  : SbeMessage(data, length)
4028  {
4029  checkCompatibility();
4030  }
4031 
4032  /// Creates an instance over the given SBE message.
4033  explicit
4035  const SbeMessage& message)
4036  : SbeMessage(message)
4037  {
4038  assert(message.valid());
4039 
4040  checkCompatibility();
4041  }
4042 
4043  /// Creates an instance over the given memory block.
4044  /// Performs no checks.
4046  void* data,
4047  EncodedLength length,
4048  NoInit,
4049  NoCheck)
4051  : SbeMessage(data, length, NoCheck())
4052  {
4053  assert(schemaId() == Schema::Id);
4054  assert(version() >= Schema::MinimalVersion);
4055  assert(TemplateId == templateId());
4056  }
4057 
4058  /// Message type = RetransmitReject.
4063  {
4064  return MessageType::RetransmitReject;
4065  }
4066 
4067  /// Message type = RetransmitReject.
4068 
4069  /// Client connection identification on the gateway assigned
4070  /// by B3.
4074  {
4076 
4077  return ordinary<SessionID>(offset);
4078  }
4079 
4080  /// Client connection identification on the gateway assigned
4081  /// by B3.
4082  ThisType& setSessionId(SessionID value)
4084  {
4086 
4087  setOrdinary(offset, value);
4088  return *this;
4089  }
4090 
4091  /// Matches Negotiate timestamp.
4095  {
4097 
4098  return ordinary<UTCTimestampNanos>(offset);
4099  }
4100 
4101  /// Matches Negotiate timestamp.
4104  {
4106 
4107  setOrdinary(offset, value);
4108  return *this;
4109  }
4110 
4111  /// Identifies the code of reject retransmission.
4116  {
4118 
4119  return enumeration<RetransmitRejectCode>(offset);
4120  }
4121 
4122  /// Identifies the code of reject retransmission.
4123  ThisType&
4127  {
4129 
4130  setEnumeration<RetransmitRejectCode>(offset, value);
4131  return *this;
4132  }
4133 
4134  /// Minimal size of message body in bytes.
4137  static
4138  BlockLength
4142  {
4143  return
4144  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
4145  13;
4146  }
4147 
4148  /// Size of message body in bytes.
4153  {
4154  return
4155  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
4156  minimalBlockLength(version);
4157  }
4158 
4159  /// Minimal variable fields size (when variable-length fields are empty).
4163  static
4164  MessageSize
4167  {
4168  return
4169  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
4170  0;
4171  }
4172 
4173  /// Maximal message size.
4177  static UInt64 getMaxMessageSize(UInt8)
4179  {
4180  return
4181  static_cast<UInt64>(MessageHeaderBuilder::Size) +
4182  blockLength(Schema::Version);
4183  }
4184 
4185  /// Reset all variable-length fields if any.
4188  {
4189  return *this;
4190  }
4191 
4192  /// Reset all variable-length and optional fields if any.
4193  ThisType& reset()
4195  {
4196  resetVariableFields();
4197  return *this;
4198  }
4199 
4200  /// \return class name.
4204  static const Char* className()
4205  {
4206  return "RetransmitReject14";
4207  }
4208 
4209  /// FIX message type.
4213  static StrRef fixType()
4215  {
4216  return constructStrRef("RetransmitReject14");
4217  }
4218 
4219  /// \return a human-readable presentation.
4221  std::string toString() const;
4222 
4223  /// \return the end of the message.
4225  const void* tail() const
4227  {
4228  return
4229  toOpaquePtr(
4230  advanceByBytes(
4231  binary(),
4232  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
4233  MessageHeader::Size));
4234  }
4235 
4236  /// \return the size occupied by the message.
4240  {
4241  return
4242  SbeMessage::calculateBinarySize(tail());
4243  }
4244 
4245 private:
4246  void checkLength(
4247  EncodedLength length, SchemaVersion version) const
4248  {
4249  const EncodedLength minimalRequiredLength =
4250  minimalBlockLength(version) +
4251  MessageHeader::Size +
4252  getMinimalVariableFieldsSize(version);
4253 
4254  checkBinaryLength(
4255  *this, length, minimalRequiredLength);
4256  }
4257 
4258  void checkCompatibility() const
4259  {
4260  assert(TemplateId == templateId());
4261 
4262  checkSchema<Schema>(schemaId(), version());
4263  checkLength(bufferSize(), version());
4264  }
4265 };
4266 
4267 /// SimpleNewOrder message submits a simple new order focused on sent only main parameters with low complexity. Used by client to enter a simple order in the system.
4270 : SbeMessage
4271 {
4272  /// Used template schema.
4274 
4275  /// This type alias.
4277 
4278  /// Message template ID from SBE schema.
4279  enum { TemplateId = 100 };
4280 
4281  /// Initializes a blank instance.
4283 
4284  /// Initializes an instance over the given memory block.
4286  void* data,
4287  EncodedLength length,
4288  SchemaVersion version = Schema::Version)
4289  : SbeMessage(data, length, version)
4290  {
4291  checkVersion<Schema>(version);
4292  checkLength(length, version);
4293  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4294  reset();
4295  }
4296 
4297  /// Initializes an instance over the given memory block
4298  /// With no variable-length fields initialization
4299  /// It is assumed that the user does such an initialization manually.
4301  void* data,
4302  EncodedLength length,
4303  NoFieldsInit,
4304  SchemaVersion version = Schema::Version)
4305  : SbeMessage(data, length, version)
4306  {
4307  checkVersion<Schema>(version);
4308  checkLength(length, version);
4309  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4310  resetVariableFields();
4311  }
4312 
4313  /// Creates an instance over the given memory block.
4315  void* data,
4316  EncodedLength length,
4317  NoInit)
4318  : SbeMessage(data, length)
4319  {
4320  checkCompatibility();
4321  }
4322 
4323  /// Creates an instance over the given SBE message.
4324  explicit
4326  const SbeMessage& message)
4327  : SbeMessage(message)
4328  {
4329  assert(message.valid());
4330 
4331  checkCompatibility();
4332  }
4333 
4334  /// Creates an instance over the given memory block.
4335  /// Performs no checks.
4337  void* data,
4338  EncodedLength length,
4339  NoInit,
4340  NoCheck)
4342  : SbeMessage(data, length, NoCheck())
4343  {
4344  assert(schemaId() == Schema::Id);
4345  assert(version() >= Schema::MinimalVersion);
4346  assert(TemplateId == templateId());
4347  }
4348 
4349  /// Message type = SimpleNewOrder.
4354  {
4355  return MessageType::SimpleNewOrder;
4356  }
4357 
4358  /// Message type = SimpleNewOrder.
4359 
4360  /// Common header to all inbound business messages.
4362  const InboundBusinessHeader&
4365  {
4367 
4368  return accessOrdinary<InboundBusinessHeader>(offset);
4369  }
4370 
4371  /// Common header to all inbound business messages.
4374  {
4376  return accessOrdinary<InboundBusinessHeader>(offset);
4377  }
4378 
4379  /// Identifies the order tag identification.
4381  bool ordTagId(OrdTagID& value) const
4383  {
4385 
4386  return ordinary(value, offset, NullOrdTagID());
4387  }
4388 
4389  /// Identifies the order tag identification.
4390  ThisType& setOrdTagId(OrdTagID value)
4392  {
4394 
4395  setOrdinary(offset, value);
4396  return *this;
4397  }
4398 
4399  ThisType& setOrdTagIdToNull()
4401  {
4403 
4404  setOrdinary(offset, NullOrdTagID());
4405  return *this;
4406  }
4407 
4408  /// Resets Market Protections. When Market Protections are
4409  /// triggered, the Exchange will not accept new orders for
4410  /// that product group without tag MMProtectionReset: True =
4411  /// Reset Market Maker Protection; False = Do nothing related
4412  /// to Market Maker Protection.
4416  {
4418 
4419  return enumeration<Boolean>(offset);
4420  }
4421 
4422  /// Resets Market Protections. When Market Protections are
4423  /// triggered, the Exchange will not accept new orders for
4424  /// that product group without tag MMProtectionReset: True =
4425  /// Reset Market Maker Protection; False = Do nothing related
4426  /// to Market Maker Protection.
4429  {
4431 
4432  setEnumeration<Boolean>(offset, value);
4433  return *this;
4434  }
4435 
4436  /// Unique identifier of the order as assigned by the market
4437  /// participant.
4441  {
4443 
4444  return ordinary<ClOrdID>(offset);
4445  }
4446 
4447  /// Unique identifier of the order as assigned by the market
4448  /// participant.
4449  ThisType& setClOrdId(ClOrdID value)
4451  {
4453 
4454  setOrdinary(offset, value);
4455  return *this;
4456  }
4457 
4458  /// Account mnemonic of the order.
4460  bool account(AccountOptional& value) const
4462  {
4464 
4465  return ordinary(value, offset, NullAccountOptional());
4466  }
4467 
4468  /// Account mnemonic of the order.
4469  ThisType& setAccount(AccountOptional value)
4471  {
4473 
4474  setOrdinary(offset, value);
4475  return *this;
4476  }
4477 
4478  ThisType& setAccountToNull()
4480  {
4482 
4483  setOrdinary(offset, NullAccountOptional());
4484  return *this;
4485  }
4486 
4487  /// Identifies the original location for routing orders.
4491  {
4494 
4495  return fixedStr<length>(offset);
4496  }
4497 
4498  /// Identifies the original location for routing orders.
4499  ThisType& setSenderLocation(StrRef value)
4501  {
4504 
4505  setFixedStr<length>(offset, value);
4506  return *this;
4507  }
4508 
4509  /// Identifies the trader who is inserting an order.
4513  {
4516 
4517  return fixedStr<length>(offset);
4518  }
4519 
4520  /// Identifies the trader who is inserting an order.
4521  ThisType& setEnteringTrader(StrRef value)
4523  {
4526 
4527  setFixedStr<length>(offset, value);
4528  return *this;
4529  }
4530 
4531  /// Indicates which order should be cancelled due to Self-
4532  /// Trade Prevention.
4537  {
4539 
4540  return enumeration<SelfTradePreventionInstruction>(offset);
4541  }
4542 
4543  /// Indicates which order should be cancelled due to Self-
4544  /// Trade Prevention.
4545  ThisType&
4549  {
4551 
4552  setEnumeration<SelfTradePreventionInstruction>(offset, value);
4553  return *this;
4554  }
4555 
4556  /// Security identification as defined by exchange.
4560  {
4562 
4563  return ordinary<SecurityID>(offset);
4564  }
4565 
4566  /// Security identification as defined by exchange.
4567  ThisType& setSecurityId(SecurityID value)
4569  {
4571 
4572  setOrdinary(offset, value);
4573  return *this;
4574  }
4575 
4576  /// Identifies the class of the SecurityID (Exchange Symbol).
4581  {
4582  return SecurityIDSource::ExchangeSymbol;
4583  }
4584 
4585  /// Identifies the class of the SecurityID (Exchange Symbol).
4586 
4587  /// Market to which the symbol belongs.
4593  {
4594  return constructStrRef("BVMF");
4595  }
4596 
4597  /// Side of order.
4601  {
4603 
4604  return enumeration<Side>(offset);
4605  }
4606 
4607  /// Side of order.
4608  ThisType& setSide(Side::Enum value)
4610  {
4612 
4613  setEnumeration<Side>(offset, value);
4614  return *this;
4615  }
4616 
4617  /// Order type.
4621  {
4623 
4624  return enumeration<SimpleOrdType>(offset);
4625  }
4626 
4627  /// Order type.
4628  ThisType&
4630  SimpleOrdType::Enum value)
4632  {
4634 
4635  setEnumeration<SimpleOrdType>(offset, value);
4636  return *this;
4637  }
4638 
4639  /// Specifies how long the order remains in effect.
4643  {
4645 
4646  return enumeration<SimpleTimeInForce>(offset);
4647  }
4648 
4649  /// Specifies how long the order remains in effect.
4650  ThisType&
4654  {
4656 
4657  setEnumeration<SimpleTimeInForce>(offset, value);
4658  return *this;
4659  }
4660 
4661  /// Indicates additional order instruction.
4663  bool
4665  RoutingInstruction::Enum& value) const
4667  {
4669 
4670  return enumeration<RoutingInstruction>(value, offset, NullUint8EnumEncoding());
4671  }
4672 
4673  /// Indicates additional order instruction.
4674  ThisType&
4678  {
4680 
4681  setEnumeration<RoutingInstruction>(offset, value);
4682  return *this;
4683  }
4684 
4687  {
4689 
4690  setOrdinary(offset, NullUint8EnumEncoding());
4691  return *this;
4692  }
4693 
4694  /// Quantity ordered.
4698  {
4700 
4701  return ordinary<Quantity>(offset);
4702  }
4703 
4704  /// Quantity ordered.
4705  ThisType& setOrderQty(Quantity value)
4707  {
4709 
4710  setOrdinary(offset, value);
4711  return *this;
4712  }
4713 
4714  /// Price per share or contract. Conditionally required if the
4715  /// order type requires a price (not market orders and RLP).
4717  bool price(PriceOptional& value) const
4719  {
4721 
4722  return decimal(value, offset, NullPriceOptional());
4723  }
4724 
4725  /// Price per share or contract. Conditionally required if the
4726  /// order type requires a price (not market orders and RLP).
4727  ThisType& setPrice(PriceOptional value)
4729  {
4731 
4732  setOrdinary(offset, value);
4733  return *this;
4734  }
4735 
4736  ThisType& setPriceToNull()
4738  {
4740 
4741  setOrdinary(offset, NullPriceOptional());
4742  return *this;
4743  }
4744 
4745  /// Unique identifier of investor for self trade
4746  /// prevention/mass cancel on behalf purposes.
4748  bool investorId(InvestorID& value) const
4750  {
4752 
4753  return ordinary(value, offset, NullInvestorID());
4754  }
4755 
4756  /// Unique identifier of investor for self trade
4757  /// prevention/mass cancel on behalf purposes.
4758  ThisType& setInvestorId(InvestorID value)
4760  {
4762 
4763  setOrdinary(offset, value);
4764  return *this;
4765  }
4766 
4769  {
4771 
4772  setOrdinary(offset, NullInvestorID());
4773  return *this;
4774  }
4775 
4776  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
4778  StrRef memo() const
4780  {
4781  return getVariableLengthField(memoAccess(), *this);
4782  }
4783 
4784  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
4785  ThisType& setMemo(StrRef value)
4786  {
4787  setVariableLengthField(
4788  memoAccess(),
4789  value,
4790  *this);
4791 
4792  return *this;
4793  }
4794 
4795  /// Minimal size of message body in bytes.
4798  static
4799  BlockLength
4803  {
4804  return
4805  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
4806  84;
4807  }
4808 
4809  /// Size of message body in bytes.
4814  {
4815  return
4816  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
4817  minimalBlockLength(version);
4818  }
4819 
4820  /// Minimal variable fields size (when variable-length fields are empty).
4824  static
4825  MessageSize
4828  {
4829  return
4830  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
4831  static_cast<MessageSize>(MemoEncoding::Size);
4832  }
4833 
4834  /// Maximal message size.
4838  static UInt64 getMaxMessageSize(UInt8)
4840  {
4841  return
4843  }
4844 
4845  /// Reset all variable-length fields if any.
4848  {
4849  setMemoToNull();
4850  return *this;
4851  }
4852 
4853  /// Reset all variable-length and optional fields if any.
4854  ThisType& reset()
4856  {
4857  setOrdTagIdToNull();
4858  setAccountToNull();
4859  setRoutingInstructionToNull();
4860  setPriceToNull();
4861  setInvestorIdToNull();
4862 
4863  resetVariableFields();
4864  return *this;
4865  }
4866 
4867  /// \return class name.
4871  static const Char* className()
4872  {
4873  return "SimpleNewOrder100";
4874  }
4875 
4876  /// FIX message type.
4880  static StrRef fixType()
4882  {
4883  return constructStrRef("SimpleNewOrder100");
4884  }
4885 
4886  /// \return a human-readable presentation.
4888  std::string toString() const;
4889 
4890  /// \return the end of the message.
4892  const void* tail() const
4894  {
4895  return
4896  toOpaquePtr(
4897  (memo().end()));
4898  }
4899 
4900  /// \return the size occupied by the message.
4904  {
4905  return
4906  SbeMessage::calculateBinarySize(tail());
4907  }
4908 
4909 private:
4910  void checkLength(
4911  EncodedLength length, SchemaVersion version) const
4912  {
4913  const EncodedLength minimalRequiredLength =
4914  minimalBlockLength(version) +
4915  MessageHeader::Size +
4916  getMinimalVariableFieldsSize(version);
4917 
4918  checkBinaryLength(
4919  *this, length, minimalRequiredLength);
4920  }
4921 
4922  /// Checks variable fields consistency.
4923  void checkVarLenFields() const
4924  {
4925  variableLengthFields().
4926  checkTail<MemoEncoding>();
4927  }
4928 
4929  void checkCompatibility() const
4930  {
4931  assert(TemplateId == templateId());
4932 
4933  checkSchema<Schema>(schemaId(), version());
4934  checkLength(bufferSize(), version());
4935  checkVarLenFields();
4936  }
4937 
4938  /// Access helper.
4939  struct memoAccess
4940  {
4941  MemoEncoding&
4942  operator()(
4943  const SimpleNewOrder100& obj) const
4945  {
4946  return obj.
4947  variableLengthFields().
4948  head<MemoEncoding>();
4949  }
4950  };
4951 
4952  /// Reset the field.
4953  /// All the following data will be invalidated.
4954  ThisType& setMemoToNull()
4956  {
4957  setVariableLengthFieldToNull(memoAccess(), *this);
4958 
4959  return *this;
4960  }
4961 };
4962 
4963 /// The SimpleModifyOrder submits a simple modify request for basic parameters like price and quantity. The client sends the SimpleModifyOrder message to B3 to modify some order values only.
4966 : SbeMessage
4967 {
4968  /// Used template schema.
4970 
4971  /// This type alias.
4973 
4974  /// Message template ID from SBE schema.
4975  enum { TemplateId = 101 };
4976 
4977  /// Initializes a blank instance.
4979 
4980  /// Initializes an instance over the given memory block.
4982  void* data,
4983  EncodedLength length,
4984  SchemaVersion version = Schema::Version)
4985  : SbeMessage(data, length, version)
4986  {
4987  checkVersion<Schema>(version);
4988  checkLength(length, version);
4989  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4990  reset();
4991  }
4992 
4993  /// Initializes an instance over the given memory block
4994  /// With no variable-length fields initialization
4995  /// It is assumed that the user does such an initialization manually.
4997  void* data,
4998  EncodedLength length,
4999  NoFieldsInit,
5000  SchemaVersion version = Schema::Version)
5001  : SbeMessage(data, length, version)
5002  {
5003  checkVersion<Schema>(version);
5004  checkLength(length, version);
5005  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
5006  resetVariableFields();
5007  }
5008 
5009  /// Creates an instance over the given memory block.
5011  void* data,
5012  EncodedLength length,
5013  NoInit)
5014  : SbeMessage(data, length)
5015  {
5016  checkCompatibility();
5017  }
5018 
5019  /// Creates an instance over the given SBE message.
5020  explicit
5022  const SbeMessage& message)
5023  : SbeMessage(message)
5024  {
5025  assert(message.valid());
5026 
5027  checkCompatibility();
5028  }
5029 
5030  /// Creates an instance over the given memory block.
5031  /// Performs no checks.
5033  void* data,
5034  EncodedLength length,
5035  NoInit,
5036  NoCheck)
5038  : SbeMessage(data, length, NoCheck())
5039  {
5040  assert(schemaId() == Schema::Id);
5041  assert(version() >= Schema::MinimalVersion);
5042  assert(TemplateId == templateId());
5043  }
5044 
5045  /// Message type = SimpleModifyOrder.
5050  {
5051  return MessageType::SimpleModifyOrder;
5052  }
5053 
5054  /// Message type = SimpleModifyOrder.
5055 
5056  /// Common header to all inbound business messages.
5058  const InboundBusinessHeader&
5061  {
5063 
5064  return accessOrdinary<InboundBusinessHeader>(offset);
5065  }
5066 
5067  /// Common header to all inbound business messages.
5070  {
5072  return accessOrdinary<InboundBusinessHeader>(offset);
5073  }
5074 
5075  /// Identifies the order tag identification.
5077  bool ordTagId(OrdTagID& value) const
5079  {
5081 
5082  return ordinary(value, offset, NullOrdTagID());
5083  }
5084 
5085  /// Identifies the order tag identification.
5086  ThisType& setOrdTagId(OrdTagID value)
5088  {
5090 
5091  setOrdinary(offset, value);
5092  return *this;
5093  }
5094 
5095  ThisType& setOrdTagIdToNull()
5097  {
5099 
5100  setOrdinary(offset, NullOrdTagID());
5101  return *this;
5102  }
5103 
5104  /// Resets Market Protections. When Market Protections are
5105  /// triggered, the Exchange will not accept new orders for
5106  /// that product group without tag MMProtectionReset: True =
5107  /// Reset Market Maker Protection; False = Do nothing related
5108  /// to Market Maker Protection.
5112  {
5114 
5115  return enumeration<Boolean>(offset);
5116  }
5117 
5118  /// Resets Market Protections. When Market Protections are
5119  /// triggered, the Exchange will not accept new orders for
5120  /// that product group without tag MMProtectionReset: True =
5121  /// Reset Market Maker Protection; False = Do nothing related
5122  /// to Market Maker Protection.
5125  {
5127 
5128  setEnumeration<Boolean>(offset, value);
5129  return *this;
5130  }
5131 
5132  /// Unique identifier of the order as assigned by the market
5133  /// participant.
5137  {
5139 
5140  return ordinary<ClOrdID>(offset);
5141  }
5142 
5143  /// Unique identifier of the order as assigned by the market
5144  /// participant.
5145  ThisType& setClOrdId(ClOrdID value)
5147  {
5149 
5150  setOrdinary(offset, value);
5151  return *this;
5152  }
5153 
5154  /// Account mnemonic of the order.
5156  bool account(AccountOptional& value) const
5158  {
5160 
5161  return ordinary(value, offset, NullAccountOptional());
5162  }
5163 
5164  /// Account mnemonic of the order.
5165  ThisType& setAccount(AccountOptional value)
5167  {
5169 
5170  setOrdinary(offset, value);
5171  return *this;
5172  }
5173 
5174  ThisType& setAccountToNull()
5176  {
5178 
5179  setOrdinary(offset, NullAccountOptional());
5180  return *this;
5181  }
5182 
5183  /// Identifies the original location for routing orders.
5187  {
5190 
5191  return fixedStr<length>(offset);
5192  }
5193 
5194  /// Identifies the original location for routing orders.
5195  ThisType& setSenderLocation(StrRef value)
5197  {
5200 
5201  setFixedStr<length>(offset, value);
5202  return *this;
5203  }
5204 
5205  /// Identifies the trader who is inserting an order.
5209  {
5212 
5213  return fixedStr<length>(offset);
5214  }
5215 
5216  /// Identifies the trader who is inserting an order.
5217  ThisType& setEnteringTrader(StrRef value)
5219  {
5222 
5223  setFixedStr<length>(offset, value);
5224  return *this;
5225  }
5226 
5227  /// Indicates which order should be cancelled due to Self-
5228  /// Trade Prevention.
5233  {
5235 
5236  return enumeration<SelfTradePreventionInstruction>(offset);
5237  }
5238 
5239  /// Indicates which order should be cancelled due to Self-
5240  /// Trade Prevention.
5241  ThisType&
5245  {
5247 
5248  setEnumeration<SelfTradePreventionInstruction>(offset, value);
5249  return *this;
5250  }
5251 
5252  /// Security identification as defined by exchange.
5256  {
5258 
5259  return ordinary<SecurityID>(offset);
5260  }
5261 
5262  /// Security identification as defined by exchange.
5263  ThisType& setSecurityId(SecurityID value)
5265  {
5267 
5268  setOrdinary(offset, value);
5269  return *this;
5270  }
5271 
5272  /// Identifies the class of the SecurityID (Exchange Symbol).
5277  {
5278  return SecurityIDSource::ExchangeSymbol;
5279  }
5280 
5281  /// Identifies the class of the SecurityID (Exchange Symbol).
5282 
5283  /// Market to which the symbol belongs.
5289  {
5290  return constructStrRef("BVMF");
5291  }
5292 
5293  /// Side of order.
5297  {
5299 
5300  return enumeration<Side>(offset);
5301  }
5302 
5303  /// Side of order.
5304  ThisType& setSide(Side::Enum value)
5306  {
5308 
5309  setEnumeration<Side>(offset, value);
5310  return *this;
5311  }
5312 
5313  /// Order type.
5317  {
5319 
5320  return enumeration<SimpleOrdType>(offset);
5321  }
5322 
5323  /// Order type.
5324  ThisType&
5326  SimpleOrdType::Enum value)
5328  {
5330 
5331  setEnumeration<SimpleOrdType>(offset, value);
5332  return *this;
5333  }
5334 
5335  /// Specifies how long the order remains in effect.
5339  {
5341 
5342  return enumeration<SimpleTimeInForce>(offset);
5343  }
5344 
5345  /// Specifies how long the order remains in effect.
5346  ThisType&
5350  {
5352 
5353  setEnumeration<SimpleTimeInForce>(offset, value);
5354  return *this;
5355  }
5356 
5357  /// Indicates additional order instruction.
5359  bool
5361  RoutingInstruction::Enum& value) const
5363  {
5365 
5366  return enumeration<RoutingInstruction>(value, offset, NullUint8EnumEncoding());
5367  }
5368 
5369  /// Indicates additional order instruction.
5370  ThisType&
5374  {
5376 
5377  setEnumeration<RoutingInstruction>(offset, value);
5378  return *this;
5379  }
5380 
5383  {
5385 
5386  setOrdinary(offset, NullUint8EnumEncoding());
5387  return *this;
5388  }
5389 
5390  /// Quantity ordered.
5394  {
5396 
5397  return ordinary<Quantity>(offset);
5398  }
5399 
5400  /// Quantity ordered.
5401  ThisType& setOrderQty(Quantity value)
5403  {
5405 
5406  setOrdinary(offset, value);
5407  return *this;
5408  }
5409 
5410  /// Price per share or contract. Conditionally required if the
5411  /// order type requires a price (not market orders and RLP).
5413  bool price(PriceOptional& value) const
5415  {
5417 
5418  return decimal(value, offset, NullPriceOptional());
5419  }
5420 
5421  /// Price per share or contract. Conditionally required if the
5422  /// order type requires a price (not market orders and RLP).
5423  ThisType& setPrice(PriceOptional value)
5425  {
5427 
5428  setOrdinary(offset, value);
5429  return *this;
5430  }
5431 
5432  ThisType& setPriceToNull()
5434  {
5436 
5437  setOrdinary(offset, NullPriceOptional());
5438  return *this;
5439  }
5440 
5441  /// Unique identifier for order as assigned by the exchange.
5443  bool orderId(OrderIDOptional& value) const
5445  {
5447 
5448  return ordinary(value, offset, NullOrderIDOptional());
5449  }
5450 
5451  /// Unique identifier for order as assigned by the exchange.
5452  ThisType& setOrderId(OrderIDOptional value)
5454  {
5456 
5457  setOrdinary(offset, value);
5458  return *this;
5459  }
5460 
5461  ThisType& setOrderIdToNull()
5463  {
5465 
5466  setOrdinary(offset, NullOrderIDOptional());
5467  return *this;
5468  }
5469 
5470  /// ClOrdID which should be replaced.
5472  bool origClOrdId(ClOrdIDOptional& value) const
5474  {
5476 
5477  return ordinary(value, offset, NullClOrdIDOptional());
5478  }
5479 
5480  /// ClOrdID which should be replaced.
5483  {
5485 
5486  setOrdinary(offset, value);
5487  return *this;
5488  }
5489 
5492  {
5494 
5495  setOrdinary(offset, NullClOrdIDOptional());
5496  return *this;
5497  }
5498 
5499  /// Unique identifier of investor for self trade
5500  /// prevention/mass cancel on behalf purposes.
5502  bool investorId(InvestorID& value) const
5504  {
5506 
5507  return ordinary(value, offset, NullInvestorID());
5508  }
5509 
5510  /// Unique identifier of investor for self trade
5511  /// prevention/mass cancel on behalf purposes.
5512  ThisType& setInvestorId(InvestorID value)
5514  {
5516 
5517  setOrdinary(offset, value);
5518  return *this;
5519  }
5520 
5523  {
5525 
5526  setOrdinary(offset, NullInvestorID());
5527  return *this;
5528  }
5529 
5530  /// Type of account associated with an order.
5535  {
5536  return AccountType::RegularAccount;
5537  }
5538 
5539  /// Type of account associated with an order.
5540 
5541  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
5543  StrRef memo() const
5545  {
5546  return getVariableLengthField(memoAccess(), *this);
5547  }
5548 
5549  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
5550  ThisType& setMemo(StrRef value)
5551  {
5552  setVariableLengthField(
5553  memoAccess(),
5554  value,
5555  *this);
5556 
5557  return *this;
5558  }
5559 
5560  /// Minimal size of message body in bytes.
5563  static
5564  BlockLength
5568  {
5569  return
5570  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
5571  100;
5572  }
5573 
5574  /// Size of message body in bytes.
5579  {
5580  return
5581  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
5582  minimalBlockLength(version);
5583  }
5584 
5585  /// Minimal variable fields size (when variable-length fields are empty).
5589  static
5590  MessageSize
5593  {
5594  return
5595  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
5596  static_cast<MessageSize>(MemoEncoding::Size);
5597  }
5598 
5599  /// Maximal message size.
5603  static UInt64 getMaxMessageSize(UInt8)
5605  {
5606  return
5608  }
5609 
5610  /// Reset all variable-length fields if any.
5613  {
5614  setMemoToNull();
5615  return *this;
5616  }
5617 
5618  /// Reset all variable-length and optional fields if any.
5619  ThisType& reset()
5621  {
5622  setOrdTagIdToNull();
5623  setAccountToNull();
5624  setRoutingInstructionToNull();
5625  setPriceToNull();
5626  setOrderIdToNull();
5627  setOrigClOrdIdToNull();
5628  setInvestorIdToNull();
5629 
5630  resetVariableFields();
5631  return *this;
5632  }
5633 
5634  /// \return class name.
5638  static const Char* className()
5639  {
5640  return "SimpleModifyOrder101";
5641  }
5642 
5643  /// FIX message type.
5647  static StrRef fixType()
5649  {
5650  return constructStrRef("SimpleModifyOrder101");
5651  }
5652 
5653  /// \return a human-readable presentation.
5655  std::string toString() const;
5656 
5657  /// \return the end of the message.
5659  const void* tail() const
5661  {
5662  return
5663  toOpaquePtr(
5664  (memo().end()));
5665  }
5666 
5667  /// \return the size occupied by the message.
5671  {
5672  return
5673  SbeMessage::calculateBinarySize(tail());
5674  }
5675 
5676 private:
5677  void checkLength(
5678  EncodedLength length, SchemaVersion version) const
5679  {
5680  const EncodedLength minimalRequiredLength =
5681  minimalBlockLength(version) +
5682  MessageHeader::Size +
5683  getMinimalVariableFieldsSize(version);
5684 
5685  checkBinaryLength(
5686  *this, length, minimalRequiredLength);
5687  }
5688 
5689  /// Checks variable fields consistency.
5690  void checkVarLenFields() const
5691  {
5692  variableLengthFields().
5693  checkTail<MemoEncoding>();
5694  }
5695 
5696  void checkCompatibility() const
5697  {
5698  assert(TemplateId == templateId());
5699 
5700  checkSchema<Schema>(schemaId(), version());
5701  checkLength(bufferSize(), version());
5702  checkVarLenFields();
5703  }
5704 
5705  /// Access helper.
5706  struct memoAccess
5707  {
5708  MemoEncoding&
5709  operator()(
5710  const SimpleModifyOrder101& obj) const
5712  {
5713  return obj.
5714  variableLengthFields().
5715  head<MemoEncoding>();
5716  }
5717  };
5718 
5719  /// Reset the field.
5720  /// All the following data will be invalidated.
5721  ThisType& setMemoToNull()
5723  {
5724  setVariableLengthFieldToNull(memoAccess(), *this);
5725 
5726  return *this;
5727  }
5728 };
5729 
5730 /// NewOrderSingle message is used to enter an order in the system; the behavior of an order can be affected by many parameters such as order type and order type qualifier.
5733 : SbeMessage
5734 {
5735  /// Used template schema.
5737 
5738  /// This type alias.
5740 
5741  /// Message template ID from SBE schema.
5742  enum { TemplateId = 102 };
5743 
5744  /// Initializes a blank instance.
5746 
5747  /// Initializes an instance over the given memory block.
5749  void* data,
5750  EncodedLength length,
5751  SchemaVersion version = Schema::Version)
5752  : SbeMessage(data, length, version)
5753  {
5754  checkVersion<Schema>(version);
5755  checkLength(length, version);
5756  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
5757  reset();
5758  }
5759 
5760  /// Initializes an instance over the given memory block
5761  /// With no variable-length fields initialization
5762  /// It is assumed that the user does such an initialization manually.
5764  void* data,
5765  EncodedLength length,
5766  NoFieldsInit,
5767  SchemaVersion version = Schema::Version)
5768  : SbeMessage(data, length, version)
5769  {
5770  checkVersion<Schema>(version);
5771  checkLength(length, version);
5772  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
5773  resetVariableFields();
5774  }
5775 
5776  /// Creates an instance over the given memory block.
5778  void* data,
5779  EncodedLength length,
5780  NoInit)
5781  : SbeMessage(data, length)
5782  {
5783  checkCompatibility();
5784  }
5785 
5786  /// Creates an instance over the given SBE message.
5787  explicit
5789  const SbeMessage& message)
5790  : SbeMessage(message)
5791  {
5792  assert(message.valid());
5793 
5794  checkCompatibility();
5795  }
5796 
5797  /// Creates an instance over the given memory block.
5798  /// Performs no checks.
5800  void* data,
5801  EncodedLength length,
5802  NoInit,
5803  NoCheck)
5805  : SbeMessage(data, length, NoCheck())
5806  {
5807  assert(schemaId() == Schema::Id);
5808  assert(version() >= Schema::MinimalVersion);
5809  assert(TemplateId == templateId());
5810  }
5811 
5812  /// Message type = NewOrderSingle.
5817  {
5818  return MessageType::NewOrderSingle;
5819  }
5820 
5821  /// Message type = NewOrderSingle.
5822 
5823  /// Common header to all inbound business messages.
5825  const InboundBusinessHeader&
5828  {
5830 
5831  return accessOrdinary<InboundBusinessHeader>(offset);
5832  }
5833 
5834  /// Common header to all inbound business messages.
5837  {
5839  return accessOrdinary<InboundBusinessHeader>(offset);
5840  }
5841 
5842  /// Identifies the order tag identification.
5844  bool ordTagId(OrdTagID& value) const
5846  {
5848 
5849  return ordinary(value, offset, NullOrdTagID());
5850  }
5851 
5852  /// Identifies the order tag identification.
5853  ThisType& setOrdTagId(OrdTagID value)
5855  {
5857 
5858  setOrdinary(offset, value);
5859  return *this;
5860  }
5861 
5862  ThisType& setOrdTagIdToNull()
5864  {
5866 
5867  setOrdinary(offset, NullOrdTagID());
5868  return *this;
5869  }
5870 
5871  /// Resets Market Protections. When Market Protections are
5872  /// triggered, the Exchange will not accept new orders for
5873  /// that product group without tag MMProtectionReset: True =
5874  /// Reset Market Maker Protection; False = Do nothing related
5875  /// to Market Maker Protection.
5879  {
5881 
5882  return enumeration<Boolean>(offset);
5883  }
5884 
5885  /// Resets Market Protections. When Market Protections are
5886  /// triggered, the Exchange will not accept new orders for
5887  /// that product group without tag MMProtectionReset: True =
5888  /// Reset Market Maker Protection; False = Do nothing related
5889  /// to Market Maker Protection.
5892  {
5894 
5895  setEnumeration<Boolean>(offset, value);
5896  return *this;
5897  }
5898 
5899  /// Unique identifier of the order as assigned by the market
5900  /// participant.
5904  {
5906 
5907  return ordinary<ClOrdID>(offset);
5908  }
5909 
5910  /// Unique identifier of the order as assigned by the market
5911  /// participant.
5912  ThisType& setClOrdId(ClOrdID value)
5914  {
5916 
5917  setOrdinary(offset, value);
5918  return *this;
5919  }
5920 
5921  /// Account mnemonic of the order.
5923  bool account(AccountOptional& value) const
5925  {
5927 
5928  return ordinary(value, offset, NullAccountOptional());
5929  }
5930 
5931  /// Account mnemonic of the order.
5932  ThisType& setAccount(AccountOptional value)
5934  {
5936 
5937  setOrdinary(offset, value);
5938  return *this;
5939  }
5940 
5941  ThisType& setAccountToNull()
5943  {
5945 
5946  setOrdinary(offset, NullAccountOptional());
5947  return *this;
5948  }
5949 
5950  /// Identifies the original location for routing orders.
5954  {
5957 
5958  return fixedStr<length>(offset);
5959  }
5960 
5961  /// Identifies the original location for routing orders.
5962  ThisType& setSenderLocation(StrRef value)
5964  {
5967 
5968  setFixedStr<length>(offset, value);
5969  return *this;
5970  }
5971 
5972  /// Identifies the trader who is inserting an order.
5976  {
5979 
5980  return fixedStr<length>(offset);
5981  }
5982 
5983  /// Identifies the trader who is inserting an order.
5984  ThisType& setEnteringTrader(StrRef value)
5986  {
5989 
5990  setFixedStr<length>(offset, value);
5991  return *this;
5992  }
5993 
5994  /// Indicates which order should be cancelled due to Self-
5995  /// Trade Prevention.
6000  {
6002 
6003  return enumeration<SelfTradePreventionInstruction>(offset);
6004  }
6005 
6006  /// Indicates which order should be cancelled due to Self-
6007  /// Trade Prevention.
6008  ThisType&
6012  {
6014 
6015  setEnumeration<SelfTradePreventionInstruction>(offset, value);
6016  return *this;
6017  }
6018 
6019  /// Security identification as defined by exchange.
6023  {
6025 
6026  return ordinary<SecurityID>(offset);
6027  }
6028 
6029  /// Security identification as defined by exchange.
6030  ThisType& setSecurityId(SecurityID value)
6032  {
6034 
6035  setOrdinary(offset, value);
6036  return *this;
6037  }
6038 
6039  /// Identifies the class of the SecurityID (Exchange Symbol).
6044  {
6045  return SecurityIDSource::ExchangeSymbol;
6046  }
6047 
6048  /// Identifies the class of the SecurityID (Exchange Symbol).
6049 
6050  /// Market to which the symbol belongs.
6056  {
6057  return constructStrRef("BVMF");
6058  }
6059 
6060  /// Side of order.
6064  {
6066 
6067  return enumeration<Side>(offset);
6068  }
6069 
6070  /// Side of order.
6071  ThisType& setSide(Side::Enum value)
6073  {
6075 
6076  setEnumeration<Side>(offset, value);
6077  return *this;
6078  }
6079 
6080  /// Order type.
6084  {
6086 
6087  return enumeration<OrdType>(offset);
6088  }
6089 
6090  /// Order type.
6091  ThisType& setOrdType(OrdType::Enum value)
6093  {
6095 
6096  setEnumeration<OrdType>(offset, value);
6097  return *this;
6098  }
6099 
6100  /// Specifies how long the order remains in effect.
6104  {
6106 
6107  return enumeration<TimeInForce>(offset);
6108  }
6109 
6110  /// Specifies how long the order remains in effect.
6113  {
6115 
6116  setEnumeration<TimeInForce>(offset, value);
6117  return *this;
6118  }
6119 
6120  /// Indicates additional order instruction.
6122  bool
6124  RoutingInstruction::Enum& value) const
6126  {
6128 
6129  return enumeration<RoutingInstruction>(value, offset, NullUint8EnumEncoding());
6130  }
6131 
6132  /// Indicates additional order instruction.
6133  ThisType&
6137  {
6139 
6140  setEnumeration<RoutingInstruction>(offset, value);
6141  return *this;
6142  }
6143 
6146  {
6148 
6149  setOrdinary(offset, NullUint8EnumEncoding());
6150  return *this;
6151  }
6152 
6153  /// Quantity ordered.
6157  {
6159 
6160  return ordinary<Quantity>(offset);
6161  }
6162 
6163  /// Quantity ordered.
6164  ThisType& setOrderQty(Quantity value)
6166  {
6168 
6169  setOrdinary(offset, value);
6170  return *this;
6171  }
6172 
6173  /// Price per share or contract. Conditionally required if the
6174  /// order type requires a price (not market orders and RLP).
6176  bool price(PriceOptional& value) const
6178  {
6180 
6181  return decimal(value, offset, NullPriceOptional());
6182  }
6183 
6184  /// Price per share or contract. Conditionally required if the
6185  /// order type requires a price (not market orders and RLP).
6186  ThisType& setPrice(PriceOptional value)
6188  {
6190 
6191  setOrdinary(offset, value);
6192  return *this;
6193  }
6194 
6195  ThisType& setPriceToNull()
6197  {
6199 
6200  setOrdinary(offset, NullPriceOptional());
6201  return *this;
6202  }
6203 
6204  /// The stop price of a stop limit order (Conditionally
6205  /// required if OrdType = 4).
6207  bool stopPx(PriceOptional& value) const
6209  {
6211 
6212  return decimal(value, offset, NullPriceOptional());
6213  }
6214 
6215  /// The stop price of a stop limit order (Conditionally
6216  /// required if OrdType = 4).
6217  ThisType& setStopPx(PriceOptional value)
6219  {
6221 
6222  setOrdinary(offset, value);
6223  return *this;
6224  }
6225 
6226  ThisType& setStopPxToNull()
6228  {
6230 
6231  setOrdinary(offset, NullPriceOptional());
6232  return *this;
6233  }
6234 
6235  /// Minimum quantity of an order to be executed.
6237  bool minQty(QuantityOptional& value) const
6239  {
6241 
6242  return ordinary(value, offset, NullQuantityOptional());
6243  }
6244 
6245  /// Minimum quantity of an order to be executed.
6246  ThisType& setMinQty(QuantityOptional value)
6248  {
6250 
6251  setOrdinary(offset, value);
6252  return *this;
6253  }
6254 
6255  ThisType& setMinQtyToNull()
6257  {
6259 
6260  setOrdinary(offset, NullQuantityOptional());
6261  return *this;
6262  }
6263 
6264  /// Maximum number of shares or contracts within an order to
6265  /// be shown on the match engine at any given time.
6267  bool maxFloor(QuantityOptional& value) const
6269  {
6271 
6272  return ordinary(value, offset, NullQuantityOptional());
6273  }
6274 
6275  /// Maximum number of shares or contracts within an order to
6276  /// be shown on the match engine at any given time.
6279  {
6281 
6282  setOrdinary(offset, value);
6283  return *this;
6284  }
6285 
6286  ThisType& setMaxFloorToNull()
6288  {
6290 
6291  setOrdinary(offset, NullQuantityOptional());
6292  return *this;
6293  }
6294 
6295  /// Identifies the trader who is executing an order.
6297  bool executingTrader(StrRef& value) const
6299  {
6302 
6303  return fixedStr<length>(value, offset);
6304  }
6305 
6306  /// Identifies the trader who is executing an order.
6307  ThisType& setExecutingTrader(StrRef value)
6309  {
6312 
6313  setFixedStr<length>(offset, value);
6314  return *this;
6315  }
6316 
6319  {
6322 
6323  setFixedStr<length>(offset, StrRef());
6324  return *this;
6325  }
6326 
6327  /// Date of order expiration (last day the order can trade),
6328  /// always expressed in terms of the local market date.
6330  bool expireDate(Timestamp& value) const
6332  {
6333  typedef LocalMktDateOptional FieldValue;
6334 
6336 
6337  FieldValue fieldValue;
6338 
6339  if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
6340  {
6341  value = localMktDateToTimestamp(fieldValue);
6342  return true;
6343  }
6344  return false;
6345  }
6346 
6347  /// Date of order expiration (last day the order can trade),
6348  /// always expressed in terms of the local market date.
6349  ThisType& setExpireDate(Timestamp value)
6351  {
6353 
6354  setOrdinary(offset, timestampToLocalMktDate(value));
6355  return *this;
6356  }
6357 
6360  {
6362 
6363  setOrdinary(offset, NullLocalMktDateOptional());
6364  return *this;
6365  }
6366 
6367  /// Identifies the custodian.
6369  bool custodianInfo(CustodianInfo& value) const
6371  {
6373 
6374  return ordinary(value, offset, NullCustodianInfo());
6375  }
6376 
6377  /// Identifies the custodian.
6380  {
6382 
6383  setOrdinary(offset, value);
6384  return *this;
6385  }
6386 
6389  {
6391 
6392  setOrdinary(offset, NullCustodianInfo());
6393  return *this;
6394  }
6395 
6396  /// Unique identifier of investor for self trade
6397  /// prevention/mass cancel on behalf purposes.
6399  bool investorId(InvestorID& value) const
6401  {
6403 
6404  return ordinary(value, offset, NullInvestorID());
6405  }
6406 
6407  /// Unique identifier of investor for self trade
6408  /// prevention/mass cancel on behalf purposes.
6409  ThisType& setInvestorId(InvestorID value)
6411  {
6413 
6414  setOrdinary(offset, value);
6415  return *this;
6416  }
6417 
6420  {
6422 
6423  setOrdinary(offset, NullInvestorID());
6424  return *this;
6425  }
6426 
6427  /// Client-assigned identification of a strategy.
6429  bool
6431  StrategyIDOptional& value) const
6433  {
6435 
6436  return ordinary(value, offset, NullStrategyIDOptional());
6437  }
6438 
6439  /// Client-assigned identification of a strategy.
6442  {
6444 
6445  setOrdinary(offset, value);
6446  return *this;
6447  }
6448 
6451  {
6453 
6454  setOrdinary(offset, NullStrategyIDOptional());
6455  return *this;
6456  }
6457 
6458  /// Account used for associating risk limits (when defined).
6462  {
6465 
6466  return ordinary(value, offset, NullAccountOptional(), since);
6467  }
6468 
6469  /// Account used for associating risk limits (when defined).
6471  {
6474 
6475  setOrdinary(offset, value, since);
6476  return *this;
6477  }
6478 
6480  {
6483 
6484  setOrdinary(offset, NullAccountOptional(), since);
6485  return *this;
6486  }
6487 
6488  /// Identifies the trading desk.
6490  StrRef deskId() const
6492  {
6493  return getVariableLengthField(deskIDAccess(), *this);
6494  }
6495 
6496  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
6498  StrRef memo() const
6500  {
6501  return getVariableLengthField(memoAccess(), *this);
6502  }
6503 
6504  /// Identifies the trading desk.
6505  ThisType& setDeskId(StrRef value)
6506  {
6507  setVariableLengthField(
6508  deskIDAccess(),
6509  value,
6510  *this);
6511 
6512  return *this;
6513  }
6514 
6515  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
6516  ThisType& setMemo(StrRef value)
6517  {
6518  setVariableLengthField(
6519  memoAccess(),
6520  value,
6521  *this);
6522 
6523  return *this;
6524  }
6525 
6526  /// Minimal size of message body in bytes.
6531  {
6532  return
6533  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
6534  (version >= 5)
6535  ? 135
6536  : 131;
6537  }
6538 
6539  /// Size of message body in bytes.
6544  {
6545  return
6546  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
6547  minimalBlockLength(version);
6548  }
6549 
6550  /// Minimal variable fields size (when variable-length fields are empty).
6554  static
6555  MessageSize
6558  {
6559  return
6560  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
6561  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
6562  }
6563 
6564  /// Maximal message size.
6568  static UInt64 getMaxMessageSize(UInt8)
6570  {
6571  return
6573  }
6574 
6575  /// Reset all variable-length fields if any.
6578  {
6579  setDeskIdToNull();
6580  setMemoToNull();
6581  return *this;
6582  }
6583 
6584  /// Reset all variable-length and optional fields if any.
6585  ThisType& reset()
6587  {
6588  setOrdTagIdToNull();
6589  setAccountToNull();
6590  setRoutingInstructionToNull();
6591  setPriceToNull();
6592  setStopPxToNull();
6593  setMinQtyToNull();
6594  setMaxFloorToNull();
6595  setExecutingTraderToNull();
6596  setExpireDateToNull();
6597  setCustodianInfoToNull();
6598  setInvestorIdToNull();
6599  setStrategyIdToNull();
6600 
6601  if (version() >= 5)
6602  {
6603  setTradingSubAccountToNull();
6604  }
6605 
6606  resetVariableFields();
6607  return *this;
6608  }
6609 
6610  /// \return class name.
6614  static const Char* className()
6615  {
6616  return "NewOrderSingle102";
6617  }
6618 
6619  /// FIX message type.
6623  static StrRef fixType()
6625  {
6626  return constructStrRef("NewOrderSingle102");
6627  }
6628 
6629  /// \return a human-readable presentation.
6631  std::string toString() const;
6632 
6633  /// \return the end of the message.
6635  const void* tail() const
6637  {
6638  return
6639  toOpaquePtr(
6640  (memo().end()));
6641  }
6642 
6643  /// \return the size occupied by the message.
6647  {
6648  return
6649  SbeMessage::calculateBinarySize(tail());
6650  }
6651 
6652 private:
6653  void checkLength(
6654  EncodedLength length, SchemaVersion version) const
6655  {
6656  const EncodedLength minimalRequiredLength =
6657  minimalBlockLength(version) +
6658  MessageHeader::Size +
6659  getMinimalVariableFieldsSize(version);
6660 
6661  checkBinaryLength(
6662  *this, length, minimalRequiredLength);
6663  }
6664 
6665  /// Checks variable fields consistency.
6666  void checkVarLenFields() const
6667  {
6668  variableLengthFields().
6669  checkTail<DeskIDEncoding>().
6670  checkTail<MemoEncoding>();
6671  }
6672 
6673  void checkCompatibility() const
6674  {
6675  assert(TemplateId == templateId());
6676 
6677  checkSchema<Schema>(schemaId(), version());
6678  checkLength(bufferSize(), version());
6679  checkVarLenFields();
6680  }
6681 
6682  /// Access helper.
6683  struct deskIDAccess
6684  {
6686  operator()(
6687  const NewOrderSingle102& obj) const
6689  {
6690  return obj.
6691  variableLengthFields().
6692  head<DeskIDEncoding>();
6693  }
6694  };
6695 
6696  /// Access helper.
6697  struct memoAccess
6698  {
6699  MemoEncoding&
6700  operator()(
6701  const NewOrderSingle102& obj) const
6703  {
6704  return obj.
6705  variableLengthFields().
6706  tail<DeskIDEncoding>().
6707  head<MemoEncoding>();
6708  }
6709  };
6710 
6711  /// Reset the field.
6712  /// All the following data will be invalidated.
6713  ThisType& setDeskIdToNull()
6715  {
6716  setVariableLengthFieldToNull(deskIDAccess(), *this);
6717 
6718  return *this;
6719  }
6720 
6721  /// Reset the field.
6722  /// All the following data will be invalidated.
6723  ThisType& setMemoToNull()
6725  {
6726  setVariableLengthFieldToNull(memoAccess(), *this);
6727 
6728  return *this;
6729  }
6730 };
6731 
6732 /// Sent by client system to replace an existing order.
6735 : SbeMessage
6736 {
6737  /// Used template schema.
6739 
6740  /// This type alias.
6742 
6743  /// Message template ID from SBE schema.
6744  enum { TemplateId = 104 };
6745 
6746  /// Initializes a blank instance.
6748 
6749  /// Initializes an instance over the given memory block.
6751  void* data,
6752  EncodedLength length,
6753  SchemaVersion version = Schema::Version)
6754  : SbeMessage(data, length, version)
6755  {
6756  checkVersion<Schema>(version);
6757  checkLength(length, version);
6758  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
6759  reset();
6760  }
6761 
6762  /// Initializes an instance over the given memory block
6763  /// With no variable-length fields initialization
6764  /// It is assumed that the user does such an initialization manually.
6766  void* data,
6767  EncodedLength length,
6768  NoFieldsInit,
6769  SchemaVersion version = Schema::Version)
6770  : SbeMessage(data, length, version)
6771  {
6772  checkVersion<Schema>(version);
6773  checkLength(length, version);
6774  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
6775  resetVariableFields();
6776  }
6777 
6778  /// Creates an instance over the given memory block.
6780  void* data,
6781  EncodedLength length,
6782  NoInit)
6783  : SbeMessage(data, length)
6784  {
6785  checkCompatibility();
6786  }
6787 
6788  /// Creates an instance over the given SBE message.
6789  explicit
6791  const SbeMessage& message)
6792  : SbeMessage(message)
6793  {
6794  assert(message.valid());
6795 
6796  checkCompatibility();
6797  }
6798 
6799  /// Creates an instance over the given memory block.
6800  /// Performs no checks.
6802  void* data,
6803  EncodedLength length,
6804  NoInit,
6805  NoCheck)
6807  : SbeMessage(data, length, NoCheck())
6808  {
6809  assert(schemaId() == Schema::Id);
6810  assert(version() >= Schema::MinimalVersion);
6811  assert(TemplateId == templateId());
6812  }
6813 
6814  /// Message type = OrderCancelReplaceRequest.
6819  {
6820  return MessageType::OrderCancelReplaceRequest;
6821  }
6822 
6823  /// Message type = OrderCancelReplaceRequest.
6824 
6825  /// Common header to all inbound business messages.
6827  const InboundBusinessHeader&
6830  {
6832 
6833  return accessOrdinary<InboundBusinessHeader>(offset);
6834  }
6835 
6836  /// Common header to all inbound business messages.
6839  {
6841  return accessOrdinary<InboundBusinessHeader>(offset);
6842  }
6843 
6844  /// Identifies the order tag identification.
6846  bool ordTagId(OrdTagID& value) const
6848  {
6850 
6851  return ordinary(value, offset, NullOrdTagID());
6852  }
6853 
6854  /// Identifies the order tag identification.
6855  ThisType& setOrdTagId(OrdTagID value)
6857  {
6859 
6860  setOrdinary(offset, value);
6861  return *this;
6862  }
6863 
6864  ThisType& setOrdTagIdToNull()
6866  {
6868 
6869  setOrdinary(offset, NullOrdTagID());
6870  return *this;
6871  }
6872 
6873  /// Resets Market Protections. When Market Protections are
6874  /// triggered, the Exchange will not accept new orders for
6875  /// that product group without tag MMProtectionReset: True =
6876  /// Reset Market Maker Protection; False = Do nothing related
6877  /// to Market Maker Protection.
6881  {
6883 
6884  return enumeration<Boolean>(offset);
6885  }
6886 
6887  /// Resets Market Protections. When Market Protections are
6888  /// triggered, the Exchange will not accept new orders for
6889  /// that product group without tag MMProtectionReset: True =
6890  /// Reset Market Maker Protection; False = Do nothing related
6891  /// to Market Maker Protection.
6894  {
6896 
6897  setEnumeration<Boolean>(offset, value);
6898  return *this;
6899  }
6900 
6901  /// Unique identifier of the order as assigned by the market
6902  /// participant.
6906  {
6908 
6909  return ordinary<ClOrdID>(offset);
6910  }
6911 
6912  /// Unique identifier of the order as assigned by the market
6913  /// participant.
6914  ThisType& setClOrdId(ClOrdID value)
6916  {
6918 
6919  setOrdinary(offset, value);
6920  return *this;
6921  }
6922 
6923  /// Account mnemonic of the order.
6925  bool account(AccountOptional& value) const
6927  {
6929 
6930  return ordinary(value, offset, NullAccountOptional());
6931  }
6932 
6933  /// Account mnemonic of the order.
6934  ThisType& setAccount(AccountOptional value)
6936  {
6938 
6939  setOrdinary(offset, value);
6940  return *this;
6941  }
6942 
6943  ThisType& setAccountToNull()
6945  {
6947 
6948  setOrdinary(offset, NullAccountOptional());
6949  return *this;
6950  }
6951 
6952  /// Identifies the original location for routing orders.
6956  {
6959 
6960  return fixedStr<length>(offset);
6961  }
6962 
6963  /// Identifies the original location for routing orders.
6964  ThisType& setSenderLocation(StrRef value)
6966  {
6969 
6970  setFixedStr<length>(offset, value);
6971  return *this;
6972  }
6973 
6974  /// Identifies the trader who is inserting an order.
6978  {
6981 
6982  return fixedStr<length>(offset);
6983  }
6984 
6985  /// Identifies the trader who is inserting an order.
6986  ThisType& setEnteringTrader(StrRef value)
6988  {
6991 
6992  setFixedStr<length>(offset, value);
6993  return *this;
6994  }
6995 
6996  /// Indicates which order should be cancelled due to Self-
6997  /// Trade Prevention.
7002  {
7004 
7005  return enumeration<SelfTradePreventionInstruction>(offset);
7006  }
7007 
7008  /// Indicates which order should be cancelled due to Self-
7009  /// Trade Prevention.
7010  ThisType&
7014  {
7016 
7017  setEnumeration<SelfTradePreventionInstruction>(offset, value);
7018  return *this;
7019  }
7020 
7021  /// Security identification as defined by exchange.
7025  {
7027 
7028  return ordinary<SecurityID>(offset);
7029  }
7030 
7031  /// Security identification as defined by exchange.
7032  ThisType& setSecurityId(SecurityID value)
7034  {
7036 
7037  setOrdinary(offset, value);
7038  return *this;
7039  }
7040 
7041  /// Identifies the class of the SecurityID (Exchange Symbol).
7046  {
7047  return SecurityIDSource::ExchangeSymbol;
7048  }
7049 
7050  /// Identifies the class of the SecurityID (Exchange Symbol).
7051 
7052  /// Market to which the symbol belongs.
7058  {
7059  return constructStrRef("BVMF");
7060  }
7061 
7062  /// Side of order.
7066  {
7068 
7069  return enumeration<Side>(offset);
7070  }
7071 
7072  /// Side of order.
7073  ThisType& setSide(Side::Enum value)
7075  {
7077 
7078  setEnumeration<Side>(offset, value);
7079  return *this;
7080  }
7081 
7082  /// Order type.
7086  {
7088 
7089  return enumeration<OrdType>(offset);
7090  }
7091 
7092  /// Order type.
7093  ThisType& setOrdType(OrdType::Enum value)
7095  {
7097 
7098  setEnumeration<OrdType>(offset, value);
7099  return *this;
7100  }
7101 
7102  /// Specifies how long the order remains in effect.
7104  bool timeInForce(TimeInForce::Enum& value) const
7106  {
7108 
7109  return enumeration<TimeInForce>(value, offset, NullChar());
7110  }
7111 
7112  /// Specifies how long the order remains in effect.
7115  {
7117 
7118  setEnumeration<TimeInForce>(offset, value);
7119  return *this;
7120  }
7121 
7124  {
7126 
7127  setOrdinary(offset, NullChar());
7128  return *this;
7129  }
7130 
7131  /// Indicates additional order instruction.
7133  bool
7135  RoutingInstruction::Enum& value) const
7137  {
7139 
7140  return enumeration<RoutingInstruction>(value, offset, NullUint8EnumEncoding());
7141  }
7142 
7143  /// Indicates additional order instruction.
7144  ThisType&
7148  {
7150 
7151  setEnumeration<RoutingInstruction>(offset, value);
7152  return *this;
7153  }
7154 
7157  {
7159 
7160  setOrdinary(offset, NullUint8EnumEncoding());
7161  return *this;
7162  }
7163 
7164  /// Quantity ordered.
7168  {
7170 
7171  return ordinary<Quantity>(offset);
7172  }
7173 
7174  /// Quantity ordered.
7175  ThisType& setOrderQty(Quantity value)
7177  {
7179 
7180  setOrdinary(offset, value);
7181  return *this;
7182  }
7183 
7184  /// Price per share or contract. Conditionally required if the
7185  /// order type requires a price (not market orders and RLP).
7187  bool price(PriceOptional& value) const
7189  {
7191 
7192  return decimal(value, offset, NullPriceOptional());
7193  }
7194 
7195  /// Price per share or contract. Conditionally required if the
7196  /// order type requires a price (not market orders and RLP).
7197  ThisType& setPrice(PriceOptional value)
7199  {
7201 
7202  setOrdinary(offset, value);
7203  return *this;
7204  }
7205 
7206  ThisType& setPriceToNull()
7208  {
7210 
7211  setOrdinary(offset, NullPriceOptional());
7212  return *this;
7213  }
7214 
7215  /// Unique identifier for order as assigned by the exchange.
7217  bool orderId(OrderIDOptional& value) const
7219  {
7221 
7222  return ordinary(value, offset, NullOrderIDOptional());
7223  }
7224 
7225  /// Unique identifier for order as assigned by the exchange.
7226  ThisType& setOrderId(OrderIDOptional value)
7228  {
7230 
7231  setOrdinary(offset, value);
7232  return *this;
7233  }
7234 
7235  ThisType& setOrderIdToNull()
7237  {
7239 
7240  setOrdinary(offset, NullOrderIDOptional());
7241  return *this;
7242  }
7243 
7244  /// ClOrdID which should be replaced.
7246  bool origClOrdId(ClOrdIDOptional& value) const
7248  {
7250 
7251  return ordinary(value, offset, NullClOrdIDOptional());
7252  }
7253 
7254  /// ClOrdID which should be replaced.
7257  {
7259 
7260  setOrdinary(offset, value);
7261  return *this;
7262  }
7263 
7266  {
7268 
7269  setOrdinary(offset, NullClOrdIDOptional());
7270  return *this;
7271  }
7272 
7273  /// The stop price of a stop limit order (Conditionally
7274  /// required if OrdType = 4).
7276  bool stopPx(PriceOptional& value) const
7278  {
7280 
7281  return decimal(value, offset, NullPriceOptional());
7282  }
7283 
7284  /// The stop price of a stop limit order (Conditionally
7285  /// required if OrdType = 4).
7286  ThisType& setStopPx(PriceOptional value)
7288  {
7290 
7291  setOrdinary(offset, value);
7292  return *this;
7293  }
7294 
7295  ThisType& setStopPxToNull()
7297  {
7299 
7300  setOrdinary(offset, NullPriceOptional());
7301  return *this;
7302  }
7303 
7304  /// Minimum quantity of an order to be executed.
7306  bool minQty(QuantityOptional& value) const
7308  {
7310 
7311  return ordinary(value, offset, NullQuantityOptional());
7312  }
7313 
7314  /// Minimum quantity of an order to be executed.
7315  ThisType& setMinQty(QuantityOptional value)
7317  {
7319 
7320  setOrdinary(offset, value);
7321  return *this;
7322  }
7323 
7324  ThisType& setMinQtyToNull()
7326  {
7328 
7329  setOrdinary(offset, NullQuantityOptional());
7330  return *this;
7331  }
7332 
7333  /// Maximum number of shares or contracts within an order to
7334  /// be shown on the match engine at any given time.
7336  bool maxFloor(QuantityOptional& value) const
7338  {
7340 
7341  return ordinary(value, offset, NullQuantityOptional());
7342  }
7343 
7344  /// Maximum number of shares or contracts within an order to
7345  /// be shown on the match engine at any given time.
7348  {
7350 
7351  setOrdinary(offset, value);
7352  return *this;
7353  }
7354 
7355  ThisType& setMaxFloorToNull()
7357  {
7359 
7360  setOrdinary(offset, NullQuantityOptional());
7361  return *this;
7362  }
7363 
7364  /// Identifies the trader who is executing an order.
7366  bool executingTrader(StrRef& value) const
7368  {
7371 
7372  return fixedStr<length>(value, offset);
7373  }
7374 
7375  /// Identifies the trader who is executing an order.
7376  ThisType& setExecutingTrader(StrRef value)
7378  {
7381 
7382  setFixedStr<length>(offset, value);
7383  return *this;
7384  }
7385 
7388  {
7391 
7392  setFixedStr<length>(offset, StrRef());
7393  return *this;
7394  }
7395 
7396  /// Type of account associated with an order.
7398  bool accountType(AccountType::Enum& value) const
7400  {
7402 
7403  return enumeration<AccountType>(value, offset, NullUint8EnumEncoding());
7404  }
7405 
7406  /// Type of account associated with an order.
7409  {
7411 
7412  setEnumeration<AccountType>(offset, value);
7413  return *this;
7414  }
7415 
7418  {
7420 
7421  setOrdinary(offset, NullUint8EnumEncoding());
7422  return *this;
7423  }
7424 
7425  /// Date of order expiration (last day the order can trade),
7426  /// always expressed in terms of the local market date.
7428  bool expireDate(Timestamp& value) const
7430  {
7431  typedef LocalMktDateOptional FieldValue;
7432 
7434 
7435  FieldValue fieldValue;
7436 
7437  if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
7438  {
7439  value = localMktDateToTimestamp(fieldValue);
7440  return true;
7441  }
7442  return false;
7443  }
7444 
7445  /// Date of order expiration (last day the order can trade),
7446  /// always expressed in terms of the local market date.
7447  ThisType& setExpireDate(Timestamp value)
7449  {
7451 
7452  setOrdinary(offset, timestampToLocalMktDate(value));
7453  return *this;
7454  }
7455 
7458  {
7460 
7461  setOrdinary(offset, NullLocalMktDateOptional());
7462  return *this;
7463  }
7464 
7465  /// Identifies the custodian.
7467  bool custodianInfo(CustodianInfo& value) const
7469  {
7471 
7472  return ordinary(value, offset, NullCustodianInfo());
7473  }
7474 
7475  /// Identifies the custodian.
7478  {
7480 
7481  setOrdinary(offset, value);
7482  return *this;
7483  }
7484 
7487  {
7489 
7490  setOrdinary(offset, NullCustodianInfo());
7491  return *this;
7492  }
7493 
7494  /// Unique identifier of investor for self trade
7495  /// prevention/mass cancel on behalf purposes.
7497  bool investorId(InvestorID& value) const
7499  {
7501 
7502  return ordinary(value, offset, NullInvestorID());
7503  }
7504 
7505  /// Unique identifier of investor for self trade
7506  /// prevention/mass cancel on behalf purposes.
7507  ThisType& setInvestorId(InvestorID value)
7509  {
7511 
7512  setOrdinary(offset, value);
7513  return *this;
7514  }
7515 
7518  {
7520 
7521  setOrdinary(offset, NullInvestorID());
7522  return *this;
7523  }
7524 
7525  /// Client-assigned identification of a strategy.
7527  bool
7529  StrategyIDOptional& value) const
7531  {
7533 
7534  return ordinary(value, offset, NullStrategyIDOptional());
7535  }
7536 
7537  /// Client-assigned identification of a strategy.
7540  {
7542 
7543  setOrdinary(offset, value);
7544  return *this;
7545  }
7546 
7549  {
7551 
7552  setOrdinary(offset, NullStrategyIDOptional());
7553  return *this;
7554  }
7555 
7556  /// Account used for associating risk limits (when defined).
7560  {
7563 
7564  return ordinary(value, offset, NullAccountOptional(), since);
7565  }
7566 
7567  /// Account used for associating risk limits (when defined).
7569  {
7572 
7573  setOrdinary(offset, value, since);
7574  return *this;
7575  }
7576 
7578  {
7581 
7582  setOrdinary(offset, NullAccountOptional(), since);
7583  return *this;
7584  }
7585 
7586  /// Identifies the trading desk.
7588  StrRef deskId() const
7590  {
7591  return getVariableLengthField(deskIDAccess(), *this);
7592  }
7593 
7594  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
7596  StrRef memo() const
7598  {
7599  return getVariableLengthField(memoAccess(), *this);
7600  }
7601 
7602  /// Identifies the trading desk.
7603  ThisType& setDeskId(StrRef value)
7604  {
7605  setVariableLengthField(
7606  deskIDAccess(),
7607  value,
7608  *this);
7609 
7610  return *this;
7611  }
7612 
7613  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
7614  ThisType& setMemo(StrRef value)
7615  {
7616  setVariableLengthField(
7617  memoAccess(),
7618  value,
7619  *this);
7620 
7621  return *this;
7622  }
7623 
7624  /// Minimal size of message body in bytes.
7629  {
7630  return
7631  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
7632  (version >= 5)
7633  ? 152
7634  : 148;
7635  }
7636 
7637  /// Size of message body in bytes.
7642  {
7643  return
7644  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
7645  minimalBlockLength(version);
7646  }
7647 
7648  /// Minimal variable fields size (when variable-length fields are empty).
7652  static
7653  MessageSize
7656  {
7657  return
7658  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
7659  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
7660  }
7661 
7662  /// Maximal message size.
7666  static UInt64 getMaxMessageSize(UInt8)
7668  {
7669  return
7671  }
7672 
7673  /// Reset all variable-length fields if any.
7676  {
7677  setDeskIdToNull();
7678  setMemoToNull();
7679  return *this;
7680  }
7681 
7682  /// Reset all variable-length and optional fields if any.
7683  ThisType& reset()
7685  {
7686  setOrdTagIdToNull();
7687  setAccountToNull();
7688  setTimeInForceToNull();
7689  setRoutingInstructionToNull();
7690  setPriceToNull();
7691  setOrderIdToNull();
7692  setOrigClOrdIdToNull();
7693  setStopPxToNull();
7694  setMinQtyToNull();
7695  setMaxFloorToNull();
7696  setExecutingTraderToNull();
7697  setAccountTypeToNull();
7698  setExpireDateToNull();
7699  setCustodianInfoToNull();
7700  setInvestorIdToNull();
7701  setStrategyIdToNull();
7702 
7703  if (version() >= 5)
7704  {
7705  setTradingSubAccountToNull();
7706  }
7707 
7708  resetVariableFields();
7709  return *this;
7710  }
7711 
7712  /// \return class name.
7716  static const Char* className()
7717  {
7718  return "OrderCancelReplaceRequest104";
7719  }
7720 
7721  /// FIX message type.
7725  static StrRef fixType()
7727  {
7728  return constructStrRef(
7729  "OrderCancelReplaceRequest104");
7730  }
7731 
7732  /// \return a human-readable presentation.
7734  std::string toString() const;
7735 
7736  /// \return the end of the message.
7738  const void* tail() const
7740  {
7741  return
7742  toOpaquePtr(
7743  (memo().end()));
7744  }
7745 
7746  /// \return the size occupied by the message.
7750  {
7751  return
7752  SbeMessage::calculateBinarySize(tail());
7753  }
7754 
7755 private:
7756  void checkLength(
7757  EncodedLength length, SchemaVersion version) const
7758  {
7759  const EncodedLength minimalRequiredLength =
7760  minimalBlockLength(version) +
7761  MessageHeader::Size +
7762  getMinimalVariableFieldsSize(version);
7763 
7764  checkBinaryLength(
7765  *this, length, minimalRequiredLength);
7766  }
7767 
7768  /// Checks variable fields consistency.
7769  void checkVarLenFields() const
7770  {
7771  variableLengthFields().
7772  checkTail<DeskIDEncoding>().
7773  checkTail<MemoEncoding>();
7774  }
7775 
7776  void checkCompatibility() const
7777  {
7778  assert(TemplateId == templateId());
7779 
7780  checkSchema<Schema>(schemaId(), version());
7781  checkLength(bufferSize(), version());
7782  checkVarLenFields();
7783  }
7784 
7785  /// Access helper.
7786  struct deskIDAccess
7787  {
7789  operator()(
7790  const OrderCancelReplaceRequest104& obj) const
7792  {
7793  return obj.
7794  variableLengthFields().
7795  head<DeskIDEncoding>();
7796  }
7797  };
7798 
7799  /// Access helper.
7800  struct memoAccess
7801  {
7802  MemoEncoding&
7803  operator()(
7804  const OrderCancelReplaceRequest104& obj) const
7806  {
7807  return obj.
7808  variableLengthFields().
7809  tail<DeskIDEncoding>().
7810  head<MemoEncoding>();
7811  }
7812  };
7813 
7814  /// Reset the field.
7815  /// All the following data will be invalidated.
7816  ThisType& setDeskIdToNull()
7818  {
7819  setVariableLengthFieldToNull(deskIDAccess(), *this);
7820 
7821  return *this;
7822  }
7823 
7824  /// Reset the field.
7825  /// All the following data will be invalidated.
7826  ThisType& setMemoToNull()
7828  {
7829  setVariableLengthFieldToNull(memoAccess(), *this);
7830 
7831  return *this;
7832  }
7833 };
7834 
7835 /// OrderCancelRequest message submits a deletion of an existing order by referencing the original client order id.
7838 : SbeMessage
7839 {
7840  /// Used template schema.
7842 
7843  /// This type alias.
7845 
7846  /// Message template ID from SBE schema.
7847  enum { TemplateId = 105 };
7848 
7849  /// Initializes a blank instance.
7851 
7852  /// Initializes an instance over the given memory block.
7854  void* data,
7855  EncodedLength length,
7856  SchemaVersion version = Schema::Version)
7857  : SbeMessage(data, length, version)
7858  {
7859  checkVersion<Schema>(version);
7860  checkLength(length, version);
7861  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
7862  reset();
7863  }
7864 
7865  /// Initializes an instance over the given memory block
7866  /// With no variable-length fields initialization
7867  /// It is assumed that the user does such an initialization manually.
7869  void* data,
7870  EncodedLength length,
7871  NoFieldsInit,
7872  SchemaVersion version = Schema::Version)
7873  : SbeMessage(data, length, version)
7874  {
7875  checkVersion<Schema>(version);
7876  checkLength(length, version);
7877  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
7878  resetVariableFields();
7879  }
7880 
7881  /// Creates an instance over the given memory block.
7883  void* data,
7884  EncodedLength length,
7885  NoInit)
7886  : SbeMessage(data, length)
7887  {
7888  checkCompatibility();
7889  }
7890 
7891  /// Creates an instance over the given SBE message.
7892  explicit
7894  const SbeMessage& message)
7895  : SbeMessage(message)
7896  {
7897  assert(message.valid());
7898 
7899  checkCompatibility();
7900  }
7901 
7902  /// Creates an instance over the given memory block.
7903  /// Performs no checks.
7905  void* data,
7906  EncodedLength length,
7907  NoInit,
7908  NoCheck)
7910  : SbeMessage(data, length, NoCheck())
7911  {
7912  assert(schemaId() == Schema::Id);
7913  assert(version() >= Schema::MinimalVersion);
7914  assert(TemplateId == templateId());
7915  }
7916 
7917  /// Message type = OrderCancelRequest.
7922  {
7923  return MessageType::OrderCancelRequest;
7924  }
7925 
7926  /// Message type = OrderCancelRequest.
7927 
7928  /// Common header to all inbound business messages.
7930  const InboundBusinessHeader&
7933  {
7935 
7936  return accessOrdinary<InboundBusinessHeader>(offset);
7937  }
7938 
7939  /// Common header to all inbound business messages.
7942  {
7944  return accessOrdinary<InboundBusinessHeader>(offset);
7945  }
7946 
7947  /// Unique identifier of the order as assigned by the market
7948  /// participant.
7952  {
7954 
7955  return ordinary<ClOrdID>(offset);
7956  }
7957 
7958  /// Unique identifier of the order as assigned by the market
7959  /// participant.
7960  ThisType& setClOrdId(ClOrdID value)
7962  {
7964 
7965  setOrdinary(offset, value);
7966  return *this;
7967  }
7968 
7969  /// Security identification as defined by exchange.
7973  {
7975 
7976  return ordinary<SecurityID>(offset);
7977  }
7978 
7979  /// Security identification as defined by exchange.
7980  ThisType& setSecurityId(SecurityID value)
7982  {
7984 
7985  setOrdinary(offset, value);
7986  return *this;
7987  }
7988 
7989  /// Identifies the class of the SecurityID (Exchange Symbol).
7994  {
7995  return SecurityIDSource::ExchangeSymbol;
7996  }
7997 
7998  /// Identifies the class of the SecurityID (Exchange Symbol).
7999 
8000  /// Market to which the symbol belongs.
8006  {
8007  return constructStrRef("BVMF");
8008  }
8009 
8010  /// Unique identifier for order as assigned by the exchange.
8012  bool orderId(OrderIDOptional& value) const
8014  {
8016 
8017  return ordinary(value, offset, NullOrderIDOptional());
8018  }
8019 
8020  /// Unique identifier for order as assigned by the exchange.
8021  ThisType& setOrderId(OrderIDOptional value)
8023  {
8025 
8026  setOrdinary(offset, value);
8027  return *this;
8028  }
8029 
8030  ThisType& setOrderIdToNull()
8032  {
8034 
8035  setOrdinary(offset, NullOrderIDOptional());
8036  return *this;
8037  }
8038 
8039  /// ClOrdID which should be cancelled.
8041  bool origClOrdId(ClOrdIDOptional& value) const
8043  {
8045 
8046  return ordinary(value, offset, NullClOrdIDOptional());
8047  }
8048 
8049  /// ClOrdID which should be cancelled.
8052  {
8054 
8055  setOrdinary(offset, value);
8056  return *this;
8057  }
8058 
8061  {
8063 
8064  setOrdinary(offset, NullClOrdIDOptional());
8065  return *this;
8066  }
8067 
8068  /// Side of order.
8072  {
8074 
8075  return enumeration<Side>(offset);
8076  }
8077 
8078  /// Side of order.
8079  ThisType& setSide(Side::Enum value)
8081  {
8083 
8084  setEnumeration<Side>(offset, value);
8085  return *this;
8086  }
8087 
8088  /// Used to communicate a reason for a solicited cancel.
8090  bool
8094  {
8096 
8097  return enumeration<ExecRestatementReasonValidForSingleCancel>(value, offset, NullUint8EnumEncoding());
8098  }
8099 
8100  /// Used to communicate a reason for a solicited cancel.
8101  ThisType&
8105  {
8107 
8108  setEnumeration<ExecRestatementReasonValidForSingleCancel>(offset, value);
8109  return *this;
8110  }
8111 
8114  {
8116 
8117  setOrdinary(offset, NullUint8EnumEncoding());
8118  return *this;
8119  }
8120 
8121  /// Identifies the original location for routing orders.
8125  {
8128 
8129  return fixedStr<length>(offset);
8130  }
8131 
8132  /// Identifies the original location for routing orders.
8133  ThisType& setSenderLocation(StrRef value)
8135  {
8138 
8139  setFixedStr<length>(offset, value);
8140  return *this;
8141  }
8142 
8143  /// Identifies the trader who is inserting an order.
8147  {
8150 
8151  return fixedStr<length>(offset);
8152  }
8153 
8154  /// Identifies the trader who is inserting an order.
8155  ThisType& setEnteringTrader(StrRef value)
8157  {
8160 
8161  setFixedStr<length>(offset, value);
8162  return *this;
8163  }
8164 
8165  /// Identifies the trader who is executing an order.
8167  bool executingTrader(StrRef& value) const
8169  {
8172 
8173  return fixedStr<length>(value, offset);
8174  }
8175 
8176  /// Identifies the trader who is executing an order.
8177  ThisType& setExecutingTrader(StrRef value)
8179  {
8182 
8183  setFixedStr<length>(offset, value);
8184  return *this;
8185  }
8186 
8189  {
8192 
8193  setFixedStr<length>(offset, StrRef());
8194  return *this;
8195  }
8196 
8197  /// Identifies the trading desk.
8199  StrRef deskId() const
8201  {
8202  return getVariableLengthField(deskIDAccess(), *this);
8203  }
8204 
8205  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
8207  StrRef memo() const
8209  {
8210  return getVariableLengthField(memoAccess(), *this);
8211  }
8212 
8213  /// Identifies the trading desk.
8214  ThisType& setDeskId(StrRef value)
8215  {
8216  setVariableLengthField(
8217  deskIDAccess(),
8218  value,
8219  *this);
8220 
8221  return *this;
8222  }
8223 
8224  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
8225  ThisType& setMemo(StrRef value)
8226  {
8227  setVariableLengthField(
8228  memoAccess(),
8229  value,
8230  *this);
8231 
8232  return *this;
8233  }
8234 
8235  /// Minimal size of message body in bytes.
8238  static
8239  BlockLength
8243  {
8244  return
8245  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
8246  76;
8247  }
8248 
8249  /// Size of message body in bytes.
8252  static
8253  BlockLength
8257  {
8258  return
8259  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
8260  minimalBlockLength(version);
8261  }
8262 
8263  /// Minimal variable fields size (when variable-length fields are empty).
8267  static
8268  MessageSize
8271  {
8272  return
8273  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
8274  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
8275  }
8276 
8277  /// Maximal message size.
8281  static UInt64 getMaxMessageSize(UInt8)
8283  {
8284  return
8286  }
8287 
8288  /// Reset all variable-length fields if any.
8291  {
8292  setDeskIdToNull();
8293  setMemoToNull();
8294  return *this;
8295  }
8296 
8297  /// Reset all variable-length and optional fields if any.
8298  ThisType& reset()
8300  {
8301  setOrderIdToNull();
8302  setOrigClOrdIdToNull();
8303  setExecRestatementReasonToNull();
8304  setExecutingTraderToNull();
8305 
8306  resetVariableFields();
8307  return *this;
8308  }
8309 
8310  /// \return class name.
8314  static const Char* className()
8315  {
8316  return "OrderCancelRequest105";
8317  }
8318 
8319  /// FIX message type.
8323  static StrRef fixType()
8325  {
8326  return constructStrRef("OrderCancelRequest105");
8327  }
8328 
8329  /// \return a human-readable presentation.
8331  std::string toString() const;
8332 
8333  /// \return the end of the message.
8335  const void* tail() const
8337  {
8338  return
8339  toOpaquePtr(
8340  (memo().end()));
8341  }
8342 
8343  /// \return the size occupied by the message.
8347  {
8348  return
8349  SbeMessage::calculateBinarySize(tail());
8350  }
8351 
8352 private:
8353  void checkLength(
8354  EncodedLength length, SchemaVersion version) const
8355  {
8356  const EncodedLength minimalRequiredLength =
8357  minimalBlockLength(version) +
8358  MessageHeader::Size +
8359  getMinimalVariableFieldsSize(version);
8360 
8361  checkBinaryLength(
8362  *this, length, minimalRequiredLength);
8363  }
8364 
8365  /// Checks variable fields consistency.
8366  void checkVarLenFields() const
8367  {
8368  variableLengthFields().
8369  checkTail<DeskIDEncoding>().
8370  checkTail<MemoEncoding>();
8371  }
8372 
8373  void checkCompatibility() const
8374  {
8375  assert(TemplateId == templateId());
8376 
8377  checkSchema<Schema>(schemaId(), version());
8378  checkLength(bufferSize(), version());
8379  checkVarLenFields();
8380  }
8381 
8382  /// Access helper.
8383  struct deskIDAccess
8384  {
8386  operator()(
8387  const OrderCancelRequest105& obj) const
8389  {
8390  return obj.
8391  variableLengthFields().
8392  head<DeskIDEncoding>();
8393  }
8394  };
8395 
8396  /// Access helper.
8397  struct memoAccess
8398  {
8399  MemoEncoding&
8400  operator()(
8401  const OrderCancelRequest105& obj) const
8403  {
8404  return obj.
8405  variableLengthFields().
8406  tail<DeskIDEncoding>().
8407  head<MemoEncoding>();
8408  }
8409  };
8410 
8411  /// Reset the field.
8412  /// All the following data will be invalidated.
8413  ThisType& setDeskIdToNull()
8415  {
8416  setVariableLengthFieldToNull(deskIDAccess(), *this);
8417 
8418  return *this;
8419  }
8420 
8421  /// Reset the field.
8422  /// All the following data will be invalidated.
8423  ThisType& setMemoToNull()
8425  {
8426  setVariableLengthFieldToNull(memoAccess(), *this);
8427 
8428  return *this;
8429  }
8430 };
8431 
8432 /// The NewOrderCross message submits a Cross on Order Entry gateway, a two-sided order submitted by a single party/broker at the same price and quantity.
8435 : SbeMessage
8436 {
8437  /// Used template schema.
8439 
8440  /// This type alias.
8442 
8443  /// Message template ID from SBE schema.
8444  enum { TemplateId = 106 };
8445 
8446  /// Repeating group dimensions.
8447  /// Entry of SidesEntry repeating group.
8450  <
8452  >
8453  {
8454  /// Base class type.
8455  typedef
8457  <
8459  >
8461 
8462  /// This type alias.
8464 
8465  /// Initializes instance of given
8466  /// version over given memory block.
8468  void* data,
8469  EncodedLength length,
8470  SchemaVersion version)
8471  : Base(data, numericCast<Base::BlockLength>(length), version)
8472  {
8473  assert(version >= Schema::MinimalVersion);
8474  assert(length >= minimalBlockLength(version));
8475  }
8476 
8477  /// Reset all variable-length fields if any.
8480  {
8481  return *this;
8482  }
8483 
8484  /// Reset all variable-length and optional fields if any.
8485  ThisType& reset()
8487  {
8488  setAccountToNull();
8489  setEnteringFirmToNull();
8490 
8491  if (version() >= 5)
8492  {
8493  setTradingSubAccountToNull();
8494  }
8495 
8496  resetVariableFields();
8497  return *this;
8498  }
8499 
8500  /// Side of order.
8504  {
8506 
8507  return enumeration<Side>(offset);
8508  }
8509 
8510  /// Side of order.
8511  ThisType& setSide(Side::Enum value)
8513  {
8515 
8516  setEnumeration<Side>(offset, value);
8517  return *this;
8518  }
8519 
8520  /// Account mnemonic of the order.
8522  bool account(AccountOptional& value) const
8524  {
8526 
8527  return ordinary(value, offset, NullAccountOptional());
8528  }
8529 
8530  /// Account mnemonic of the order.
8531  ThisType& setAccount(AccountOptional value)
8533  {
8535 
8536  setOrdinary(offset, value);
8537  return *this;
8538  }
8539 
8540  ThisType& setAccountToNull()
8542  {
8544 
8545  setOrdinary(offset, NullAccountOptional());
8546  return *this;
8547  }
8548 
8549  /// Identifies the broker firm that will enter orders.
8551  bool enteringFirm(FirmOptional& value) const
8553  {
8555 
8556  return ordinary(value, offset, NullFirmOptional());
8557  }
8558 
8559  /// Identifies the broker firm that will enter orders.
8562  {
8564 
8565  setOrdinary(offset, value);
8566  return *this;
8567  }
8568 
8571  {
8573 
8574  setOrdinary(offset, NullFirmOptional());
8575  return *this;
8576  }
8577 
8578  /// Unique identifier of the order as assigned by the market
8579  /// participant.
8583  {
8585 
8586  return ordinary<ClOrdID>(offset);
8587  }
8588 
8589  /// Unique identifier of the order as assigned by the market
8590  /// participant.
8591  ThisType& setClOrdId(ClOrdID value)
8593  {
8595 
8596  setOrdinary(offset, value);
8597  return *this;
8598  }
8599 
8600  /// Account used for associating risk limits (when defined).
8604  {
8607 
8608  return ordinary(value, offset, NullAccountOptional(), since);
8609  }
8610 
8611  /// Account used for associating risk limits (when defined).
8613  {
8616 
8617  setOrdinary(offset, value, since);
8618  return *this;
8619  }
8620 
8622  {
8625 
8626  setOrdinary(offset, NullAccountOptional(), since);
8627  return *this;
8628  }
8629 
8630  /// \return size of entry body in bytes
8631  /// for given version of message template.
8634  static
8635  BlockLength
8639  {
8640  return
8641  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
8642  minimalBlockLength(version);
8643  }
8644 
8645  /// \return minimal size of entry body in bytes
8646  /// for given version of message template.
8651  {
8652  return
8653  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
8654  (version >= 5)
8655  ? 22
8656  : 18;
8657  }
8658 
8659  /// Entity class name.
8663  static const Char* className()
8664  {
8665  return "NewOrderCross106.SidesEntry";
8666  }
8667  };
8668 
8669  /// Repeating group containing SidesEntry entries.
8670  typedef
8673 
8674  /// Initializes a blank instance.
8676 
8677  /// Initializes an instance over the given memory block.
8679  void* data,
8680  EncodedLength length,
8681  SchemaVersion version = Schema::Version)
8682  : SbeMessage(data, length, version)
8683  {
8684  checkVersion<Schema>(version);
8685  checkLength(length, version);
8686  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
8687  reset();
8688  }
8689 
8690  /// Initializes an instance over the given memory block
8691  /// With no variable-length fields initialization
8692  /// It is assumed that the user does such an initialization manually.
8694  void* data,
8695  EncodedLength length,
8696  NoFieldsInit,
8697  SchemaVersion version = Schema::Version)
8698  : SbeMessage(data, length, version)
8699  {
8700  checkVersion<Schema>(version);
8701  checkLength(length, version);
8702  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
8703  resetVariableFields();
8704  }
8705 
8706  /// Creates an instance over the given memory block.
8708  void* data,
8709  EncodedLength length,
8710  NoInit)
8711  : SbeMessage(data, length)
8712  {
8713  checkCompatibility();
8714  }
8715 
8716  /// Creates an instance over the given SBE message.
8717  explicit
8719  const SbeMessage& message)
8720  : SbeMessage(message)
8721  {
8722  assert(message.valid());
8723 
8724  checkCompatibility();
8725  }
8726 
8727  /// Creates an instance over the given memory block.
8728  /// Performs no checks.
8730  void* data,
8731  EncodedLength length,
8732  NoInit,
8733  NoCheck)
8735  : SbeMessage(data, length, NoCheck())
8736  {
8737  assert(schemaId() == Schema::Id);
8738  assert(version() >= Schema::MinimalVersion);
8739  assert(TemplateId == templateId());
8740  }
8741 
8742  /// Message type = NewOrderCross.
8747  {
8748  return MessageType::NewOrderCross;
8749  }
8750 
8751  /// Message type = NewOrderCross.
8752 
8753  /// Common header to all inbound business messages.
8755  const InboundBusinessHeader&
8758  {
8760 
8761  return accessOrdinary<InboundBusinessHeader>(offset);
8762  }
8763 
8764  /// Common header to all inbound business messages.
8767  {
8769  return accessOrdinary<InboundBusinessHeader>(offset);
8770  }
8771 
8772  /// ID of electronically submitted cross order by the
8773  /// institution (if in response to a cross order).
8777  {
8779 
8780  return ordinary<CrossID>(offset);
8781  }
8782 
8783  /// ID of electronically submitted cross order by the
8784  /// institution (if in response to a cross order).
8785  ThisType& setCrossId(CrossID value)
8787  {
8789 
8790  setOrdinary(offset, value);
8791  return *this;
8792  }
8793 
8794  /// Identifies the original location for routing orders.
8798  {
8801 
8802  return fixedStr<length>(offset);
8803  }
8804 
8805  /// Identifies the original location for routing orders.
8806  ThisType& setSenderLocation(StrRef value)
8808  {
8811 
8812  setFixedStr<length>(offset, value);
8813  return *this;
8814  }
8815 
8816  /// Identifies the trader who is inserting an order.
8820  {
8823 
8824  return fixedStr<length>(offset);
8825  }
8826 
8827  /// Identifies the trader who is inserting an order.
8828  ThisType& setEnteringTrader(StrRef value)
8830  {
8833 
8834  setFixedStr<length>(offset, value);
8835  return *this;
8836  }
8837 
8838  /// Identifies the trader who is executing an order.
8840  bool executingTrader(StrRef& value) const
8842  {
8845 
8846  return fixedStr<length>(value, offset);
8847  }
8848 
8849  /// Identifies the trader who is executing an order.
8850  ThisType& setExecutingTrader(StrRef value)
8852  {
8855 
8856  setFixedStr<length>(offset, value);
8857  return *this;
8858  }
8859 
8862  {
8865 
8866  setFixedStr<length>(offset, StrRef());
8867  return *this;
8868  }
8869 
8870  /// Security identification as defined by exchange.
8874  {
8876 
8877  return ordinary<SecurityID>(offset);
8878  }
8879 
8880  /// Security identification as defined by exchange.
8881  ThisType& setSecurityId(SecurityID value)
8883  {
8885 
8886  setOrdinary(offset, value);
8887  return *this;
8888  }
8889 
8890  /// Identifies the class of the SecurityID (Exchange Symbol).
8895  {
8896  return SecurityIDSource::ExchangeSymbol;
8897  }
8898 
8899  /// Identifies the class of the SecurityID (Exchange Symbol).
8900 
8901  /// Market to which the symbol belongs.
8907  {
8908  return constructStrRef("BVMF");
8909  }
8910 
8911  /// Quantity ordered.
8915  {
8917 
8918  return ordinary<Quantity>(offset);
8919  }
8920 
8921  /// Quantity ordered.
8922  ThisType& setOrderQty(Quantity value)
8924  {
8926 
8927  setOrdinary(offset, value);
8928  return *this;
8929  }
8930 
8931  /// Price per share or contract. Conditionally required if the
8932  /// order type requires a price (not market orders and RLP).
8934  Price price() const
8936  {
8938 
8939  return decimal<Price>(offset);
8940  }
8941 
8942  /// Price per share or contract. Conditionally required if the
8943  /// order type requires a price (not market orders and RLP).
8944  ThisType& setPrice(Price value)
8946  {
8948 
8949  setOrdinary(offset, value);
8950  return *this;
8951  }
8952 
8953  /// Indicates cross order purpose.
8955  bool
8957  CrossedIndicator::Enum& value) const
8959  {
8961 
8962  return enumeration<CrossedIndicator>(value, offset, NullUint16EnumEncoding());
8963  }
8964 
8965  /// Indicates cross order purpose.
8966  ThisType&
8968  CrossedIndicator::Enum value)
8970  {
8972 
8973  setEnumeration<CrossedIndicator>(offset, value);
8974  return *this;
8975  }
8976 
8979  {
8981 
8982  setOrdinary(offset, NullUint16EnumEncoding());
8983  return *this;
8984  }
8985 
8986  /// Type of cross being submitted to a market. Null value
8987  /// indicates all or none cross.
8989  bool crossType(CrossType::Enum& value) const
8991  {
8993 
8994  return enumeration<CrossType>(value, offset, NullUint8EnumEncoding());
8995  }
8996 
8997  /// Type of cross being submitted to a market. Null value
8998  /// indicates all or none cross.
9001  {
9003 
9004  setEnumeration<CrossType>(offset, value);
9005  return *this;
9006  }
9007 
9010  {
9012 
9013  setOrdinary(offset, NullUint8EnumEncoding());
9014  return *this;
9015  }
9016 
9017  /// Indicates if one side or the other of a cross order should
9018  /// be prioritized. Null value indicates none is prioritized.
9020  bool
9022  CrossPrioritization::Enum& value) const
9024  {
9026 
9027  return enumeration<CrossPrioritization>(value, offset, NullUInt8());
9028  }
9029 
9030  /// Indicates if one side or the other of a cross order should
9031  /// be prioritized. Null value indicates none is prioritized.
9032  ThisType&
9036  {
9038 
9039  setEnumeration<CrossPrioritization>(offset, value);
9040  return *this;
9041  }
9042 
9045  {
9047 
9048  setOrdinary(offset, NullUInt8());
9049  return *this;
9050  }
9051 
9052  /// Maximum sweep quantity.
9054  bool maxSweepQty(QuantityOptional& value) const
9056  {
9058 
9059  return ordinary(value, offset, NullQuantityOptional());
9060  }
9061 
9062  /// Maximum sweep quantity.
9065  {
9067 
9068  setOrdinary(offset, value);
9069  return *this;
9070  }
9071 
9074  {
9076 
9077  setOrdinary(offset, NullQuantityOptional());
9078  return *this;
9079  }
9080 
9081  /// \return instance of Sides repeating group.
9083  Sides sides() const
9085  {
9086  return getGroup<Sides>(SidesAccess(), *this);
9087  }
9088 
9089  /// \return instance of Sides repeating group.
9093  {
9094  return getGroup<Sides>(SidesAccess(), *this);
9095  }
9096 
9097  /// Setup repeating group with the given number of entries.
9098  /// Sets all optional fields of the group entries to null.
9099  /// \return noSides(552) repeating group.
9101  {
9102  return constructGroup<Sides>(
9103  SidesAccess(),
9104  length,
9105  *this);
9106  }
9107 
9108  /// Setup repeating group with the given number of entries.
9109  /// \return noSides(552) repeating group.
9110  Sides
9112  Sides::Size length,
9113  NoFieldsInit)
9114  {
9115  return setupGroup<Sides>(
9116  SidesAccess(),
9117  length,
9118  *this);
9119  }
9120 
9121  /// Identifies the trading desk.
9123  StrRef deskId() const
9125  {
9126  return getVariableLengthField(deskIDAccess(), *this);
9127  }
9128 
9129  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
9131  StrRef memo() const
9133  {
9134  return getVariableLengthField(memoAccess(), *this);
9135  }
9136 
9137  /// Identifies the trading desk.
9138  ThisType& setDeskId(StrRef value)
9139  {
9140  setVariableLengthField(
9141  deskIDAccess(),
9142  value,
9143  *this);
9144 
9145  return *this;
9146  }
9147 
9148  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
9149  ThisType& setMemo(StrRef value)
9150  {
9151  setVariableLengthField(
9152  memoAccess(),
9153  value,
9154  *this);
9155 
9156  return *this;
9157  }
9158 
9159  /// Minimal size of message body in bytes.
9162  static
9163  BlockLength
9167  {
9168  return
9169  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
9170  84;
9171  }
9172 
9173  /// Size of message body in bytes.
9176  static
9177  BlockLength
9181  {
9182  return
9183  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
9184  minimalBlockLength(version);
9185  }
9186 
9187  /// Minimal variable fields size (when variable-length fields are empty).
9191  static
9192  MessageSize
9195  {
9196  return
9197  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
9198  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size) + static_cast<MessageSize>(Sides::EmptySize);
9199  }
9200 
9201  /// Maximal message size.
9205  static UInt64 getMaxMessageSize(UInt8)
9207  {
9208  return
9210  }
9211 
9212  /// Reset all variable-length fields if any.
9215  {
9216  setSidesToNull();
9217  setDeskIdToNull();
9218  setMemoToNull();
9219  return *this;
9220  }
9221 
9222  /// Reset all variable-length and optional fields if any.
9223  ThisType& reset()
9225  {
9226  setExecutingTraderToNull();
9227  setCrossedIndicatorToNull();
9228  setCrossTypeToNull();
9229  setCrossPrioritizationToNull();
9230  setMaxSweepQtyToNull();
9231 
9232  resetVariableFields();
9233  return *this;
9234  }
9235 
9236  /// \return class name.
9240  static const Char* className()
9241  {
9242  return "NewOrderCross106";
9243  }
9244 
9245  /// FIX message type.
9249  static StrRef fixType()
9251  {
9252  return constructStrRef("NewOrderCross106");
9253  }
9254 
9255  /// \return a human-readable presentation.
9257  std::string toString() const;
9258 
9259  /// \return the end of the message.
9261  const void* tail() const
9263  {
9264  return
9265  toOpaquePtr(
9266  (memo().end()));
9267  }
9268 
9269  /// \return the size occupied by the message.
9273  {
9274  return
9275  SbeMessage::calculateBinarySize(tail());
9276  }
9277 
9278 private:
9279  void checkLength(
9280  EncodedLength length, SchemaVersion version) const
9281  {
9282  const EncodedLength minimalRequiredLength =
9283  minimalBlockLength(version) +
9284  MessageHeader::Size +
9285  getMinimalVariableFieldsSize(version);
9286 
9287  checkBinaryLength(
9288  *this, length, minimalRequiredLength);
9289  }
9290 
9291  /// Checks variable fields consistency.
9292  void checkVarLenFields() const
9293  {
9294  groups().
9295  checkVariableLengthFields<Sides>().
9296  checkTail<DeskIDEncoding>().
9297  checkTail<MemoEncoding>();
9298  }
9299 
9300  void checkCompatibility() const
9301  {
9302  assert(TemplateId == templateId());
9303 
9304  checkSchema<Schema>(schemaId(), version());
9305  checkLength(bufferSize(), version());
9306  checkVarLenFields();
9307  }
9308 
9309  /// Access helper.
9310  struct SidesAccess
9311  {
9312  Sides
9313  operator()(
9314  const NewOrderCross106& obj) const
9316  {
9317  return obj.
9318  groups().
9319  head<Sides>();
9320  }
9321  };
9322 
9323  /// Reset an instance of the repeating group.
9324  /// All the following data will be invalidated.
9325  void setSidesToNull()
9327  {
9328  resetGroup<Sides>(SidesAccess(), *this);
9329  }
9330 
9331  /// Access helper.
9332  struct deskIDAccess
9333  {
9335  operator()(
9336  const NewOrderCross106& obj) const
9338  {
9339  return obj.
9340  groups().
9341  variableLengthFields<Sides>().
9342  head<DeskIDEncoding>();
9343  }
9344  };
9345 
9346  /// Access helper.
9347  struct memoAccess
9348  {
9349  MemoEncoding&
9350  operator()(
9351  const NewOrderCross106& obj) const
9353  {
9354  return obj.
9355  groups().
9356  variableLengthFields<Sides>().
9357  tail<DeskIDEncoding>().
9358  head<MemoEncoding>();
9359  }
9360  };
9361 
9362  /// Reset the field.
9363  /// All the following data will be invalidated.
9364  ThisType& setDeskIdToNull()
9366  {
9367  setVariableLengthFieldToNull(deskIDAccess(), *this);
9368 
9369  return *this;
9370  }
9371 
9372  /// Reset the field.
9373  /// All the following data will be invalidated.
9374  ThisType& setMemoToNull()
9376  {
9377  setVariableLengthFieldToNull(memoAccess(), *this);
9378 
9379  return *this;
9380  }
9381 };
9382 
9383 /// Execution Report - New message is sent in response to a NewOrderSingle or SimpleNewOrder messages, or also from a restated iceberg order.
9386 : SbeMessage
9387 {
9388  /// Used template schema.
9390 
9391  /// This type alias.
9393 
9394  /// Message template ID from SBE schema.
9395  enum { TemplateId = 200 };
9396 
9397  /// Initializes a blank instance.
9399 
9400  /// Initializes an instance over the given memory block.
9402  void* data,
9403  EncodedLength length,
9404  SchemaVersion version = Schema::Version)
9405  : SbeMessage(data, length, version)
9406  {
9407  checkVersion<Schema>(version);
9408  checkLength(length, version);
9409  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
9410  reset();
9411  }
9412 
9413  /// Initializes an instance over the given memory block
9414  /// With no variable-length fields initialization
9415  /// It is assumed that the user does such an initialization manually.
9417  void* data,
9418  EncodedLength length,
9419  NoFieldsInit,
9420  SchemaVersion version = Schema::Version)
9421  : SbeMessage(data, length, version)
9422  {
9423  checkVersion<Schema>(version);
9424  checkLength(length, version);
9425  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
9426  resetVariableFields();
9427  }
9428 
9429  /// Creates an instance over the given memory block.
9431  void* data,
9432  EncodedLength length,
9433  NoInit)
9434  : SbeMessage(data, length)
9435  {
9436  checkCompatibility();
9437  }
9438 
9439  /// Creates an instance over the given SBE message.
9440  explicit
9442  const SbeMessage& message)
9443  : SbeMessage(message)
9444  {
9445  assert(message.valid());
9446 
9447  checkCompatibility();
9448  }
9449 
9450  /// Creates an instance over the given memory block.
9451  /// Performs no checks.
9453  void* data,
9454  EncodedLength length,
9455  NoInit,
9456  NoCheck)
9458  : SbeMessage(data, length, NoCheck())
9459  {
9460  assert(schemaId() == Schema::Id);
9461  assert(version() >= Schema::MinimalVersion);
9462  assert(TemplateId == templateId());
9463  }
9464 
9465  /// MessageType.ExecutionReport_New.
9470  {
9471  return MessageType::ExecutionReportNew;
9472  }
9473 
9474  /// MessageType.ExecutionReport_New.
9475 
9476  /// Common header to all outbound business messages.
9478  const OutboundBusinessHeader&
9481  {
9483 
9484  return accessOrdinary<OutboundBusinessHeader>(offset);
9485  }
9486 
9487  /// Common header to all outbound business messages.
9490  {
9492  return accessOrdinary<OutboundBusinessHeader>(offset);
9493  }
9494 
9495  /// Side of order.
9499  {
9501 
9502  return enumeration<Side>(offset);
9503  }
9504 
9505  /// Side of order.
9506  ThisType& setSide(Side::Enum value)
9508  {
9510 
9511  setEnumeration<Side>(offset, value);
9512  return *this;
9513  }
9514 
9515  /// Identifies current status of order.
9519  {
9521 
9522  return enumeration<OrdStatus>(offset);
9523  }
9524 
9525  /// Identifies current status of order.
9528  {
9530 
9531  setEnumeration<OrdStatus>(offset, value);
9532  return *this;
9533  }
9534 
9535  /// Unique identifier of the order as assigned by the market
9536  /// participant.
9540  {
9542 
9543  return ordinary<ClOrdID>(offset);
9544  }
9545 
9546  /// Unique identifier of the order as assigned by the market
9547  /// participant.
9548  ThisType& setClOrdId(ClOrdID value)
9550  {
9552 
9553  setOrdinary(offset, value);
9554  return *this;
9555  }
9556 
9557  /// Exchange-generated order identifier that changes for each
9558  /// order modification event, or quantity replenishment in
9559  /// disclosed orders.
9563  {
9565 
9566  return ordinary<OrderID>(offset);
9567  }
9568 
9569  /// Exchange-generated order identifier that changes for each
9570  /// order modification event, or quantity replenishment in
9571  /// disclosed orders.
9572  ThisType& setSecondaryOrderId(OrderID value)
9574  {
9576 
9577  setOrdinary(offset, value);
9578  return *this;
9579  }
9580 
9581  /// Security identification as defined by exchange.
9585  {
9587 
9588  return ordinary<SecurityID>(offset);
9589  }
9590 
9591  /// Security identification as defined by exchange.
9592  ThisType& setSecurityId(SecurityID value)
9594  {
9596 
9597  setOrdinary(offset, value);
9598  return *this;
9599  }
9600 
9601  /// Identifies the class of the SecurityID (Exchange Symbol).
9606  {
9607  return SecurityIDSource::ExchangeSymbol;
9608  }
9609 
9610  /// Identifies the class of the SecurityID (Exchange Symbol).
9611 
9612  /// Market to which the symbol belongs.
9618  {
9619  return constructStrRef("BVMF");
9620  }
9621 
9622  /// Unique identifier for order as assigned by the exchange.
9626  {
9628 
9629  return ordinary<OrderID>(offset);
9630  }
9631 
9632  /// Unique identifier for order as assigned by the exchange.
9633  ThisType& setOrderId(OrderID value)
9635  {
9637 
9638  setOrdinary(offset, value);
9639  return *this;
9640  }
9641 
9642  /// Account mnemonic of the order.
9644  bool account(AccountOptional& value) const
9646  {
9648 
9649  return ordinary(value, offset, NullAccountOptional());
9650  }
9651 
9652  /// Account mnemonic of the order.
9653  ThisType& setAccount(AccountOptional value)
9655  {
9657 
9658  setOrdinary(offset, value);
9659  return *this;
9660  }
9661 
9662  ThisType& setAccountToNull()
9664  {
9666 
9667  setOrdinary(offset, NullAccountOptional());
9668  return *this;
9669  }
9670 
9671  /// Unique identifier of execution message as assigned by the
9672  /// exchange – unique per instrument.
9674  ExecID execId() const
9676  {
9678 
9679  return ordinary<ExecID>(offset);
9680  }
9681 
9682  /// Unique identifier of execution message as assigned by the
9683  /// exchange – unique per instrument.
9684  ThisType& setExecId(ExecID value)
9686  {
9688 
9689  setOrdinary(offset, value);
9690  return *this;
9691  }
9692 
9693  /// Time of execution/order creation.
9697  {
9699 
9700  return ordinary<UTCTimestampNanos>(offset);
9701  }
9702 
9703  /// Time of execution/order creation.
9706  {
9708 
9709  setOrdinary(offset, value);
9710  return *this;
9711  }
9712 
9713  /// Time of receipt of related inbound message in the market
9714  /// segment path. For aggressor STOP orders, it indicates the
9715  /// moment when the order is triggered.
9717  bool
9719  UTCTimestampNanosOptional& value) const
9721  {
9723 
9724  return ordinary(value, offset, NullUTCTimestampNanosOptional());
9725  }
9726 
9727  /// Time of receipt of related inbound message in the market
9728  /// segment path. For aggressor STOP orders, it indicates the
9729  /// moment when the order is triggered.
9730  ThisType&
9734  {
9736 
9737  setOrdinary(offset, value);
9738  return *this;
9739  }
9740 
9743  {
9745 
9746  setOrdinary(offset, NullUTCTimestampNanosOptional());
9747  return *this;
9748  }
9749 
9750  /// Conditionally returned on execution reports for Market and
9751  /// Stop Protect orders. This contains the final protection
9752  /// price limit at which any unmatched quantity will rest on
9753  /// the book.
9755  bool protectionPrice(PriceOptional& value) const
9757  {
9759 
9760  return decimal(value, offset, NullPriceOptional());
9761  }
9762 
9763  /// Conditionally returned on execution reports for Market and
9764  /// Stop Protect orders. This contains the final protection
9765  /// price limit at which any unmatched quantity will rest on
9766  /// the book.
9769  {
9771 
9772  setOrdinary(offset, value);
9773  return *this;
9774  }
9775 
9778  {
9780 
9781  setOrdinary(offset, NullPriceOptional());
9782  return *this;
9783  }
9784 
9785  /// Indicates date of trading day (expressed in local time at
9786  /// place of trade). Sent in number of days since Unix epoch.
9790  {
9792 
9793  return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
9794  }
9795 
9796  /// Indicates date of trading day (expressed in local time at
9797  /// place of trade). Sent in number of days since Unix epoch.
9798  ThisType& setTradeDate(Timestamp value)
9800  {
9802 
9803  setOrdinary(offset, timestampToLocalMktDate(value));
9804  return *this;
9805  }
9806 
9807  /// Indicates if an order has been triggered and is available
9808  /// for trading. Used with Stop (Limit, with protection)
9809  /// orders and the At the Close validity.
9813  {
9815 
9816  return enumeration<Boolean>(offset);
9817  }
9818 
9819  /// Indicates if an order has been triggered and is available
9820  /// for trading. Used with Stop (Limit, with protection)
9821  /// orders and the At the Close validity.
9824  {
9826 
9827  setEnumeration<Boolean>(offset, value);
9828  return *this;
9829  }
9830 
9831  /// Used to indicate what an Execution Report represents.
9832  /// Default value is 1 (Single Security).
9834  bool
9836  MultiLegReportingType::Enum& value) const
9838  {
9840 
9841  return enumeration<MultiLegReportingType>(value, offset, NullChar());
9842  }
9843 
9844  /// Used to indicate what an Execution Report represents.
9845  /// Default value is 1 (Single Security).
9846  ThisType&
9850  {
9852 
9853  setEnumeration<MultiLegReportingType>(offset, value);
9854  return *this;
9855  }
9856 
9859  {
9861 
9862  setOrdinary(offset, NullChar());
9863  return *this;
9864  }
9865 
9866  /// Order type.
9870  {
9872 
9873  return enumeration<OrdType>(offset);
9874  }
9875 
9876  /// Order type.
9877  ThisType& setOrdType(OrdType::Enum value)
9879  {
9881 
9882  setEnumeration<OrdType>(offset, value);
9883  return *this;
9884  }
9885 
9886  /// Specifies how long the order remains in effect.
9890  {
9892 
9893  return enumeration<TimeInForce>(offset);
9894  }
9895 
9896  /// Specifies how long the order remains in effect.
9899  {
9901 
9902  setEnumeration<TimeInForce>(offset, value);
9903  return *this;
9904  }
9905 
9906  /// Date of order expiration (last day the order can trade),
9907  /// always expressed in terms of the local market date.
9909  bool expireDate(Timestamp& value) const
9911  {
9912  typedef LocalMktDateOptional FieldValue;
9913 
9915 
9916  FieldValue fieldValue;
9917 
9918  if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
9919  {
9920  value = localMktDateToTimestamp(fieldValue);
9921  return true;
9922  }
9923  return false;
9924  }
9925 
9926  /// Date of order expiration (last day the order can trade),
9927  /// always expressed in terms of the local market date.
9928  ThisType& setExpireDate(Timestamp value)
9930  {
9932 
9933  setOrdinary(offset, timestampToLocalMktDate(value));
9934  return *this;
9935  }
9936 
9939  {
9941 
9942  setOrdinary(offset, NullLocalMktDateOptional());
9943  return *this;
9944  }
9945 
9946  /// Quantity ordered.
9950  {
9952 
9953  return ordinary<Quantity>(offset);
9954  }
9955 
9956  /// Quantity ordered.
9957  ThisType& setOrderQty(Quantity value)
9959  {
9961 
9962  setOrdinary(offset, value);
9963  return *this;
9964  }
9965 
9966  /// Price per share or contract. Conditionally required if the
9967  /// order type requires a price (not market orders and RLP).
9969  bool price(PriceOptional& value) const
9971  {
9973 
9974  return decimal(value, offset, NullPriceOptional());
9975  }
9976 
9977  /// Price per share or contract. Conditionally required if the
9978  /// order type requires a price (not market orders and RLP).
9979  ThisType& setPrice(PriceOptional value)
9981  {
9983 
9984  setOrdinary(offset, value);
9985  return *this;
9986  }
9987 
9988  ThisType& setPriceToNull()
9990  {
9992 
9993  setOrdinary(offset, NullPriceOptional());
9994  return *this;
9995  }
9996 
9997  /// The stop price of a stop limit order (Conditionally
9998  /// required if OrdType = 4).
10000  bool stopPx(PriceOptional& value) const
10002  {
10004 
10005  return decimal(value, offset, NullPriceOptional());
10006  }
10007 
10008  /// The stop price of a stop limit order (Conditionally
10009  /// required if OrdType = 4).
10010  ThisType& setStopPx(PriceOptional value)
10012  {
10014 
10015  setOrdinary(offset, value);
10016  return *this;
10017  }
10018 
10019  ThisType& setStopPxToNull()
10021  {
10023 
10024  setOrdinary(offset, NullPriceOptional());
10025  return *this;
10026  }
10027 
10028  /// Minimum quantity of an order to be executed.
10030  bool minQty(QuantityOptional& value) const
10032  {
10034 
10035  return ordinary(value, offset, NullQuantityOptional());
10036  }
10037 
10038  /// Minimum quantity of an order to be executed.
10039  ThisType& setMinQty(QuantityOptional value)
10041  {
10043 
10044  setOrdinary(offset, value);
10045  return *this;
10046  }
10047 
10048  ThisType& setMinQtyToNull()
10050  {
10052 
10053  setOrdinary(offset, NullQuantityOptional());
10054  return *this;
10055  }
10056 
10057  /// Maximum number of shares or contracts within an order to
10058  /// be shown on the match engine at any given time.
10060  bool maxFloor(QuantityOptional& value) const
10062  {
10064 
10065  return ordinary(value, offset, NullQuantityOptional());
10066  }
10067 
10068  /// Maximum number of shares or contracts within an order to
10069  /// be shown on the match engine at any given time.
10072  {
10074 
10075  setOrdinary(offset, value);
10076  return *this;
10077  }
10078 
10079  ThisType& setMaxFloorToNull()
10081  {
10083 
10084  setOrdinary(offset, NullQuantityOptional());
10085  return *this;
10086  }
10087 
10088  /// ID of electronically submitted cross order by the
10089  /// institution (if in response to a cross order).
10091  bool crossId(CrossIDOptional& value) const
10093  {
10095 
10096  return ordinary(value, offset, NullCrossIDOptional());
10097  }
10098 
10099  /// ID of electronically submitted cross order by the
10100  /// institution (if in response to a cross order).
10101  ThisType& setCrossId(CrossIDOptional value)
10103  {
10105 
10106  setOrdinary(offset, value);
10107  return *this;
10108  }
10109 
10110  ThisType& setCrossIdToNull()
10112  {
10114 
10115  setOrdinary(offset, NullCrossIDOptional());
10116  return *this;
10117  }
10118 
10119  /// Time of receipt of related inbound message in the gateway.
10121  bool
10123  UTCTimestampNanosOptional& value) const
10125  {
10127 
10128  return ordinary(value, offset, NullUTCTimestampNanosOptional());
10129  }
10130 
10131  /// Time of receipt of related inbound message in the gateway.
10132  ThisType&
10136  {
10138 
10139  setOrdinary(offset, value);
10140  return *this;
10141  }
10142 
10145  {
10147 
10148  setOrdinary(offset, NullUTCTimestampNanosOptional());
10149  return *this;
10150  }
10151 
10152  /// Identifies the order tag identification.
10154  bool ordTagId(OrdTagID& value) const
10156  {
10158 
10159  return ordinary(value, offset, NullOrdTagID());
10160  }
10161 
10162  /// Identifies the order tag identification.
10163  ThisType& setOrdTagId(OrdTagID value)
10165  {
10167 
10168  setOrdinary(offset, value);
10169  return *this;
10170  }
10171 
10172  ThisType& setOrdTagIdToNull()
10174  {
10176 
10177  setOrdinary(offset, NullOrdTagID());
10178  return *this;
10179  }
10180 
10181  /// Unique identifier of investor for self trade
10182  /// prevention/mass cancel on behalf purposes.
10184  bool investorId(InvestorID& value) const
10186  {
10188 
10189  return ordinary(value, offset, NullInvestorID());
10190  }
10191 
10192  /// Unique identifier of investor for self trade
10193  /// prevention/mass cancel on behalf purposes.
10194  ThisType& setInvestorId(InvestorID value)
10196  {
10198 
10199  setOrdinary(offset, value);
10200  return *this;
10201  }
10202 
10205  {
10207 
10208  setOrdinary(offset, NullInvestorID());
10209  return *this;
10210  }
10211 
10212  /// Type of cross being submitted to a market. Null value
10213  /// indicates report is not related to cross.
10215  bool crossType(CrossType::Enum& value) const
10217  {
10219 
10220  return enumeration<CrossType>(value, offset, NullUint8EnumEncoding());
10221  }
10222 
10223  /// Type of cross being submitted to a market. Null value
10224  /// indicates report is not related to cross.
10227  {
10229 
10230  setEnumeration<CrossType>(offset, value);
10231  return *this;
10232  }
10233 
10236  {
10238 
10239  setOrdinary(offset, NullUint8EnumEncoding());
10240  return *this;
10241  }
10242 
10243  /// Indicates if one side or the other of a cross order should
10244  /// be prioritized. Null value indicates report is not
10245  /// related to cross.
10247  bool
10249  CrossPrioritization::Enum& value) const
10251  {
10253 
10254  return enumeration<CrossPrioritization>(value, offset, NullUInt8());
10255  }
10256 
10257  /// Indicates if one side or the other of a cross order should
10258  /// be prioritized. Null value indicates report is not
10259  /// related to cross.
10260  ThisType&
10264  {
10266 
10267  setEnumeration<CrossPrioritization>(offset, value);
10268  return *this;
10269  }
10270 
10273  {
10275 
10276  setOrdinary(offset, NullUInt8());
10277  return *this;
10278  }
10279 
10280  /// Resets Market Protections. When Market Protections are
10281  /// triggered, the Exchange will not accept new orders for
10282  /// that product group without tag MMProtectionReset: True =
10283  /// Reset Market Maker Protection; False = Do nothing related
10284  /// to Market Maker Protection.
10288  {
10290 
10291  return enumeration<Boolean>(value, offset, NullUInt8());
10292  }
10293 
10294  /// Resets Market Protections. When Market Protections are
10295  /// triggered, the Exchange will not accept new orders for
10296  /// that product group without tag MMProtectionReset: True =
10297  /// Reset Market Maker Protection; False = Do nothing related
10298  /// to Market Maker Protection.
10301  {
10303 
10304  setEnumeration<Boolean>(offset, value);
10305  return *this;
10306  }
10307 
10310  {
10312 
10313  setOrdinary(offset, NullUInt8());
10314  return *this;
10315  }
10316 
10317  /// Client-assigned identification of a strategy.
10319  bool
10321  StrategyIDOptional& value) const
10323  {
10325 
10326  return ordinary(value, offset, NullStrategyIDOptional());
10327  }
10328 
10329  /// Client-assigned identification of a strategy.
10332  {
10334 
10335  setOrdinary(offset, value);
10336  return *this;
10337  }
10338 
10341  {
10343 
10344  setOrdinary(offset, NullStrategyIDOptional());
10345  return *this;
10346  }
10347 
10348  /// Account used for associating risk limits (when defined).
10352  {
10355 
10356  return ordinary(value, offset, NullAccountOptional(), since);
10357  }
10358 
10359  /// Account used for associating risk limits (when defined).
10361  {
10364 
10365  setOrdinary(offset, value, since);
10366  return *this;
10367  }
10368 
10370  {
10373 
10374  setOrdinary(offset, NullAccountOptional(), since);
10375  return *this;
10376  }
10377 
10378  /// Identifies the trading desk.
10380  StrRef deskId() const
10382  {
10383  return getVariableLengthField(deskIDAccess(), *this);
10384  }
10385 
10386  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
10388  StrRef memo() const
10390  {
10391  return getVariableLengthField(memoAccess(), *this);
10392  }
10393 
10394  /// Identifies the trading desk.
10395  ThisType& setDeskId(StrRef value)
10396  {
10397  setVariableLengthField(
10398  deskIDAccess(),
10399  value,
10400  *this);
10401 
10402  return *this;
10403  }
10404 
10405  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
10406  ThisType& setMemo(StrRef value)
10407  {
10408  setVariableLengthField(
10409  memoAccess(),
10410  value,
10411  *this);
10412 
10413  return *this;
10414  }
10415 
10416  /// Minimal size of message body in bytes.
10421  {
10422  return
10423  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
10424  (version >= 5)
10425  ? 176
10426  : (version >= 3)
10427  ? 172
10428  : 152;
10429  }
10430 
10431  /// Size of message body in bytes.
10434  static
10435  BlockLength
10439  {
10440  return
10441  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
10442  minimalBlockLength(version);
10443  }
10444 
10445  /// Minimal variable fields size (when variable-length fields are empty).
10449  static
10450  MessageSize
10453  {
10454  return
10455  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
10456  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
10457  }
10458 
10459  /// Maximal message size.
10463  static UInt64 getMaxMessageSize(UInt8)
10465  {
10466  return
10468  }
10469 
10470  /// Reset all variable-length fields if any.
10473  {
10474  setDeskIdToNull();
10475  setMemoToNull();
10476  return *this;
10477  }
10478 
10479  /// Reset all variable-length and optional fields if any.
10480  ThisType& reset()
10482  {
10483  setAccountToNull();
10484  setMarketSegmentReceivedTimeToNull();
10485  setProtectionPriceToNull();
10486  setMultiLegReportingTypeToNull();
10487  setExpireDateToNull();
10488  setPriceToNull();
10489  setStopPxToNull();
10490  setMinQtyToNull();
10491  setMaxFloorToNull();
10492  setCrossIdToNull();
10493  setReceivedTimeToNull();
10494  setOrdTagIdToNull();
10495  setInvestorIdToNull();
10496  setCrossTypeToNull();
10497  setCrossPrioritizationToNull();
10498  setMmProtectionResetToNull();
10499  setStrategyIdToNull();
10500 
10501  if (version() >= 5)
10502  {
10503  setTradingSubAccountToNull();
10504  }
10505 
10506  resetVariableFields();
10507  return *this;
10508  }
10509 
10510  /// \return class name.
10514  static const Char* className()
10515  {
10516  return "ExecutionReportNew200";
10517  }
10518 
10519  /// FIX message type.
10523  static StrRef fixType()
10525  {
10526  return constructStrRef("ExecutionReportNew200");
10527  }
10528 
10529  /// \return a human-readable presentation.
10531  std::string toString() const;
10532 
10533  /// \return the end of the message.
10535  const void* tail() const
10537  {
10538  return
10539  toOpaquePtr(
10540  (memo().end()));
10541  }
10542 
10543  /// \return the size occupied by the message.
10547  {
10548  return
10549  SbeMessage::calculateBinarySize(tail());
10550  }
10551 
10552 private:
10553  void checkLength(
10554  EncodedLength length, SchemaVersion version) const
10555  {
10556  const EncodedLength minimalRequiredLength =
10557  minimalBlockLength(version) +
10558  MessageHeader::Size +
10559  getMinimalVariableFieldsSize(version);
10560 
10561  checkBinaryLength(
10562  *this, length, minimalRequiredLength);
10563  }
10564 
10565  /// Checks variable fields consistency.
10566  void checkVarLenFields() const
10567  {
10568  variableLengthFields().
10569  checkTail<DeskIDEncoding>().
10570  checkTail<MemoEncoding>();
10571  }
10572 
10573  void checkCompatibility() const
10574  {
10575  assert(TemplateId == templateId());
10576 
10577  checkSchema<Schema>(schemaId(), version());
10578  checkLength(bufferSize(), version());
10579  checkVarLenFields();
10580  }
10581 
10582  /// Access helper.
10583  struct deskIDAccess
10584  {
10586  operator()(
10587  const ExecutionReportNew200& obj) const
10589  {
10590  return obj.
10591  variableLengthFields().
10592  head<DeskIDEncoding>();
10593  }
10594  };
10595 
10596  /// Access helper.
10597  struct memoAccess
10598  {
10599  MemoEncoding&
10600  operator()(
10601  const ExecutionReportNew200& obj) const
10603  {
10604  return obj.
10605  variableLengthFields().
10606  tail<DeskIDEncoding>().
10607  head<MemoEncoding>();
10608  }
10609  };
10610 
10611  /// Reset the field.
10612  /// All the following data will be invalidated.
10613  ThisType& setDeskIdToNull()
10615  {
10616  setVariableLengthFieldToNull(deskIDAccess(), *this);
10617 
10618  return *this;
10619  }
10620 
10621  /// Reset the field.
10622  /// All the following data will be invalidated.
10623  ThisType& setMemoToNull()
10625  {
10626  setVariableLengthFieldToNull(memoAccess(), *this);
10627 
10628  return *this;
10629  }
10630 };
10631 
10632 /// Execution Report - Modify message is sent in response to OrderCancelReplaceRequest or SimpleModifyOrder messages.
10635 : SbeMessage
10636 {
10637  /// Used template schema.
10639 
10640  /// This type alias.
10642 
10643  /// Message template ID from SBE schema.
10644  enum { TemplateId = 201 };
10645 
10646  /// Initializes a blank instance.
10648 
10649  /// Initializes an instance over the given memory block.
10651  void* data,
10652  EncodedLength length,
10653  SchemaVersion version = Schema::Version)
10654  : SbeMessage(data, length, version)
10655  {
10656  checkVersion<Schema>(version);
10657  checkLength(length, version);
10658  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
10659  reset();
10660  }
10661 
10662  /// Initializes an instance over the given memory block
10663  /// With no variable-length fields initialization
10664  /// It is assumed that the user does such an initialization manually.
10666  void* data,
10667  EncodedLength length,
10668  NoFieldsInit,
10669  SchemaVersion version = Schema::Version)
10670  : SbeMessage(data, length, version)
10671  {
10672  checkVersion<Schema>(version);
10673  checkLength(length, version);
10674  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
10675  resetVariableFields();
10676  }
10677 
10678  /// Creates an instance over the given memory block.
10680  void* data,
10681  EncodedLength length,
10682  NoInit)
10683  : SbeMessage(data, length)
10684  {
10685  checkCompatibility();
10686  }
10687 
10688  /// Creates an instance over the given SBE message.
10689  explicit
10691  const SbeMessage& message)
10692  : SbeMessage(message)
10693  {
10694  assert(message.valid());
10695 
10696  checkCompatibility();
10697  }
10698 
10699  /// Creates an instance over the given memory block.
10700  /// Performs no checks.
10702  void* data,
10703  EncodedLength length,
10704  NoInit,
10705  NoCheck)
10707  : SbeMessage(data, length, NoCheck())
10708  {
10709  assert(schemaId() == Schema::Id);
10710  assert(version() >= Schema::MinimalVersion);
10711  assert(TemplateId == templateId());
10712  }
10713 
10714  /// MessageType.ExecutionReport_Modify.
10719  {
10720  return MessageType::ExecutionReportModify;
10721  }
10722 
10723  /// MessageType.ExecutionReport_Modify.
10724 
10725  /// Common header to all outbound business messages.
10727  const OutboundBusinessHeader&
10730  {
10732 
10733  return accessOrdinary<OutboundBusinessHeader>(offset);
10734  }
10735 
10736  /// Common header to all outbound business messages.
10739  {
10741  return accessOrdinary<OutboundBusinessHeader>(offset);
10742  }
10743 
10744  /// Side of order.
10748  {
10750 
10751  return enumeration<Side>(offset);
10752  }
10753 
10754  /// Side of order.
10755  ThisType& setSide(Side::Enum value)
10757  {
10759 
10760  setEnumeration<Side>(offset, value);
10761  return *this;
10762  }
10763 
10764  /// Identifies current status of order.
10768  {
10770 
10771  return enumeration<OrdStatus>(offset);
10772  }
10773 
10774  /// Identifies current status of order.
10777  {
10779 
10780  setEnumeration<OrdStatus>(offset, value);
10781  return *this;
10782  }
10783 
10784  /// Unique identifier of the order as assigned by the market
10785  /// participant.
10789  {
10791 
10792  return ordinary<ClOrdID>(offset);
10793  }
10794 
10795  /// Unique identifier of the order as assigned by the market
10796  /// participant.
10797  ThisType& setClOrdId(ClOrdID value)
10799  {
10801 
10802  setOrdinary(offset, value);
10803  return *this;
10804  }
10805 
10806  /// Exchange-generated order identifier that changes for each
10807  /// order modification event, or quantity replenishment in
10808  /// disclosed orders.
10812  {
10814 
10815  return ordinary<OrderID>(offset);
10816  }
10817 
10818  /// Exchange-generated order identifier that changes for each
10819  /// order modification event, or quantity replenishment in
10820  /// disclosed orders.
10821  ThisType& setSecondaryOrderId(OrderID value)
10823  {
10825 
10826  setOrdinary(offset, value);
10827  return *this;
10828  }
10829 
10830  /// Security identification as defined by exchange.
10834  {
10836 
10837  return ordinary<SecurityID>(offset);
10838  }
10839 
10840  /// Security identification as defined by exchange.
10841  ThisType& setSecurityId(SecurityID value)
10843  {
10845 
10846  setOrdinary(offset, value);
10847  return *this;
10848  }
10849 
10850  /// Identifies the class of the SecurityID (Exchange Symbol).
10855  {
10856  return SecurityIDSource::ExchangeSymbol;
10857  }
10858 
10859  /// Identifies the class of the SecurityID (Exchange Symbol).
10860 
10861  /// Market to which the symbol belongs.
10867  {
10868  return constructStrRef("BVMF");
10869  }
10870 
10871  /// Amount of shares open for further execution, or
10872  /// unexecuted.
10876  {
10878 
10879  return ordinary<Quantity>(offset);
10880  }
10881 
10882  /// Amount of shares open for further execution, or
10883  /// unexecuted.
10884  ThisType& setLeavesQty(Quantity value)
10886  {
10888 
10889  setOrdinary(offset, value);
10890  return *this;
10891  }
10892 
10893  /// Account mnemonic of the order.
10895  bool account(AccountOptional& value) const
10897  {
10899 
10900  return ordinary(value, offset, NullAccountOptional());
10901  }
10902 
10903  /// Account mnemonic of the order.
10904  ThisType& setAccount(AccountOptional value)
10906  {
10908 
10909  setOrdinary(offset, value);
10910  return *this;
10911  }
10912 
10913  ThisType& setAccountToNull()
10915  {
10917 
10918  setOrdinary(offset, NullAccountOptional());
10919  return *this;
10920  }
10921 
10922  /// Unique identifier of execution message as assigned by the
10923  /// exchange – unique per instrument.
10925  ExecID execId() const
10927  {
10929 
10930  return ordinary<ExecID>(offset);
10931  }
10932 
10933  /// Unique identifier of execution message as assigned by the
10934  /// exchange – unique per instrument.
10935  ThisType& setExecId(ExecID value)
10937  {
10939 
10940  setOrdinary(offset, value);
10941  return *this;
10942  }
10943 
10944  /// Time of execution/order creation.
10948  {
10950 
10951  return ordinary<UTCTimestampNanos>(offset);
10952  }
10953 
10954  /// Time of execution/order creation.
10957  {
10959 
10960  setOrdinary(offset, value);
10961  return *this;
10962  }
10963 
10964  /// Total number of shares or contracts filled.
10968  {
10970 
10971  return ordinary<Quantity>(offset);
10972  }
10973 
10974  /// Total number of shares or contracts filled.
10975  ThisType& setCumQty(Quantity value)
10977  {
10979 
10980  setOrdinary(offset, value);
10981  return *this;
10982  }
10983 
10984  /// Time of receipt of related inbound message in the market
10985  /// segment path. For aggressor STOP orders, it indicates the
10986  /// moment when the order is triggered.
10988  bool
10990  UTCTimestampNanosOptional& value) const
10992  {
10994 
10995  return ordinary(value, offset, NullUTCTimestampNanosOptional());
10996  }
10997 
10998  /// Time of receipt of related inbound message in the market
10999  /// segment path. For aggressor STOP orders, it indicates the
11000  /// moment when the order is triggered.
11001  ThisType&
11005  {
11007 
11008  setOrdinary(offset, value);
11009  return *this;
11010  }
11011 
11014  {
11016 
11017  setOrdinary(offset, NullUTCTimestampNanosOptional());
11018  return *this;
11019  }
11020 
11021  /// Unique identifier for order as assigned by the exchange.
11025  {
11027 
11028  return ordinary<OrderID>(offset);
11029  }
11030 
11031  /// Unique identifier for order as assigned by the exchange.
11032  ThisType& setOrderId(OrderID value)
11034  {
11036 
11037  setOrdinary(offset, value);
11038  return *this;
11039  }
11040 
11041  /// Value of origClOrdID field informed from the related
11042  /// request message.
11044  bool origClOrdId(ClOrdIDOptional& value) const
11046  {
11048 
11049  return ordinary(value, offset, NullClOrdIDOptional());
11050  }
11051 
11052  /// Value of origClOrdID field informed from the related
11053  /// request message.
11056  {
11058 
11059  setOrdinary(offset, value);
11060  return *this;
11061  }
11062 
11065  {
11067 
11068  setOrdinary(offset, NullClOrdIDOptional());
11069  return *this;
11070  }
11071 
11072  /// Conditionally returned on execution reports for Market and
11073  /// Stop Protect orders. This contains the final protection
11074  /// price limit at which any unmatched quantity will rest on
11075  /// the book.
11077  bool protectionPrice(PriceOptional& value) const
11079  {
11081 
11082  return decimal(value, offset, NullPriceOptional());
11083  }
11084 
11085  /// Conditionally returned on execution reports for Market and
11086  /// Stop Protect orders. This contains the final protection
11087  /// price limit at which any unmatched quantity will rest on
11088  /// the book.
11091  {
11093 
11094  setOrdinary(offset, value);
11095  return *this;
11096  }
11097 
11100  {
11102 
11103  setOrdinary(offset, NullPriceOptional());
11104  return *this;
11105  }
11106 
11107  /// Indicates date of trading day (expressed in local time at
11108  /// place of trade). Sent in number of days since Unix epoch.
11112  {
11114 
11115  return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
11116  }
11117 
11118  /// Indicates date of trading day (expressed in local time at
11119  /// place of trade). Sent in number of days since Unix epoch.
11120  ThisType& setTradeDate(Timestamp value)
11122  {
11124 
11125  setOrdinary(offset, timestampToLocalMktDate(value));
11126  return *this;
11127  }
11128 
11129  /// Indicates if an order has been triggered and is available
11130  /// for trading. Used with Stop (Limit, with protection)
11131  /// orders and the At the Close validity.
11135  {
11137 
11138  return enumeration<Boolean>(offset);
11139  }
11140 
11141  /// Indicates if an order has been triggered and is available
11142  /// for trading. Used with Stop (Limit, with protection)
11143  /// orders and the At the Close validity.
11146  {
11148 
11149  setEnumeration<Boolean>(offset, value);
11150  return *this;
11151  }
11152 
11153  /// Used to indicate what an Execution Report represents.
11154  /// Default value is 1 (Single Security).
11156  bool
11158  MultiLegReportingType::Enum& value) const
11160  {
11162 
11163  return enumeration<MultiLegReportingType>(value, offset, NullChar());
11164  }
11165 
11166  /// Used to indicate what an Execution Report represents.
11167  /// Default value is 1 (Single Security).
11168  ThisType&
11172  {
11174 
11175  setEnumeration<MultiLegReportingType>(offset, value);
11176  return *this;
11177  }
11178 
11181  {
11183 
11184  setOrdinary(offset, NullChar());
11185  return *this;
11186  }
11187 
11188  /// Order type.
11192  {
11194 
11195  return enumeration<OrdType>(offset);
11196  }
11197 
11198  /// Order type.
11199  ThisType& setOrdType(OrdType::Enum value)
11201  {
11203 
11204  setEnumeration<OrdType>(offset, value);
11205  return *this;
11206  }
11207 
11208  /// Specifies how long the order remains in effect.
11212  {
11214 
11215  return enumeration<TimeInForce>(offset);
11216  }
11217 
11218  /// Specifies how long the order remains in effect.
11221  {
11223 
11224  setEnumeration<TimeInForce>(offset, value);
11225  return *this;
11226  }
11227 
11228  /// Date of order expiration (last day the order can trade),
11229  /// always expressed in terms of the local market date.
11231  bool expireDate(Timestamp& value) const
11233  {
11234  typedef LocalMktDateOptional FieldValue;
11235 
11237 
11238  FieldValue fieldValue;
11239 
11240  if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
11241  {
11242  value = localMktDateToTimestamp(fieldValue);
11243  return true;
11244  }
11245  return false;
11246  }
11247 
11248  /// Date of order expiration (last day the order can trade),
11249  /// always expressed in terms of the local market date.
11250  ThisType& setExpireDate(Timestamp value)
11252  {
11254 
11255  setOrdinary(offset, timestampToLocalMktDate(value));
11256  return *this;
11257  }
11258 
11261  {
11263 
11264  setOrdinary(offset, NullLocalMktDateOptional());
11265  return *this;
11266  }
11267 
11268  /// Quantity ordered.
11272  {
11274 
11275  return ordinary<Quantity>(offset);
11276  }
11277 
11278  /// Quantity ordered.
11279  ThisType& setOrderQty(Quantity value)
11281  {
11283 
11284  setOrdinary(offset, value);
11285  return *this;
11286  }
11287 
11288  /// Price per share or contract. Conditionally required if the
11289  /// order type requires a price (not market orders and RLP).
11291  bool price(PriceOptional& value) const
11293  {
11295 
11296  return decimal(value, offset, NullPriceOptional());
11297  }
11298 
11299  /// Price per share or contract. Conditionally required if the
11300  /// order type requires a price (not market orders and RLP).
11301  ThisType& setPrice(PriceOptional value)
11303  {
11305 
11306  setOrdinary(offset, value);
11307  return *this;
11308  }
11309 
11310  ThisType& setPriceToNull()
11312  {
11314 
11315  setOrdinary(offset, NullPriceOptional());
11316  return *this;
11317  }
11318 
11319  /// The stop price of a stop limit order (Conditionally
11320  /// required if OrdType = 4).
11322  bool stopPx(PriceOptional& value) const
11324  {
11326 
11327  return decimal(value, offset, NullPriceOptional());
11328  }
11329 
11330  /// The stop price of a stop limit order (Conditionally
11331  /// required if OrdType = 4).
11332  ThisType& setStopPx(PriceOptional value)
11334  {
11336 
11337  setOrdinary(offset, value);
11338  return *this;
11339  }
11340 
11341  ThisType& setStopPxToNull()
11343  {
11345 
11346  setOrdinary(offset, NullPriceOptional());
11347  return *this;
11348  }
11349 
11350  /// Minimum quantity of an order to be executed.
11352  bool minQty(QuantityOptional& value) const
11354  {
11356 
11357  return ordinary(value, offset, NullQuantityOptional());
11358  }
11359 
11360  /// Minimum quantity of an order to be executed.
11361  ThisType& setMinQty(QuantityOptional value)
11363  {
11365 
11366  setOrdinary(offset, value);
11367  return *this;
11368  }
11369 
11370  ThisType& setMinQtyToNull()
11372  {
11374 
11375  setOrdinary(offset, NullQuantityOptional());
11376  return *this;
11377  }
11378 
11379  /// Maximum number of shares or contracts within an order to
11380  /// be shown on the match engine at any given time.
11382  bool maxFloor(QuantityOptional& value) const
11384  {
11386 
11387  return ordinary(value, offset, NullQuantityOptional());
11388  }
11389 
11390  /// Maximum number of shares or contracts within an order to
11391  /// be shown on the match engine at any given time.
11394  {
11396 
11397  setOrdinary(offset, value);
11398  return *this;
11399  }
11400 
11401  ThisType& setMaxFloorToNull()
11403  {
11405 
11406  setOrdinary(offset, NullQuantityOptional());
11407  return *this;
11408  }
11409 
11410  /// Time of receipt of related inbound message in the gateway.
11412  bool
11414  UTCTimestampNanosOptional& value) const
11416  {
11418 
11419  return ordinary(value, offset, NullUTCTimestampNanosOptional());
11420  }
11421 
11422  /// Time of receipt of related inbound message in the gateway.
11423  ThisType&
11427  {
11429 
11430  setOrdinary(offset, value);
11431  return *this;
11432  }
11433 
11436  {
11438 
11439  setOrdinary(offset, NullUTCTimestampNanosOptional());
11440  return *this;
11441  }
11442 
11443  /// Identifies the order tag identification.
11445  bool ordTagId(OrdTagID& value) const
11447  {
11449 
11450  return ordinary(value, offset, NullOrdTagID());
11451  }
11452 
11453  /// Identifies the order tag identification.
11454  ThisType& setOrdTagId(OrdTagID value)
11456  {
11458 
11459  setOrdinary(offset, value);
11460  return *this;
11461  }
11462 
11463  ThisType& setOrdTagIdToNull()
11465  {
11467 
11468  setOrdinary(offset, NullOrdTagID());
11469  return *this;
11470  }
11471 
11472  /// Unique identifier of investor for self trade
11473  /// prevention/mass cancel on behalf purposes.
11475  bool investorId(InvestorID& value) const
11477  {
11479 
11480  return ordinary(value, offset, NullInvestorID());
11481  }
11482 
11483  /// Unique identifier of investor for self trade
11484  /// prevention/mass cancel on behalf purposes.
11485  ThisType& setInvestorId(InvestorID value)
11487  {
11489 
11490  setOrdinary(offset, value);
11491  return *this;
11492  }
11493 
11496  {
11498 
11499  setOrdinary(offset, NullInvestorID());
11500  return *this;
11501  }
11502 
11503  /// Resets Market Protections. When Market Protections are
11504  /// triggered, the Exchange will not accept new orders for
11505  /// that product group without tag MMProtectionReset: True =
11506  /// Reset Market Maker Protection; False = Do nothing related
11507  /// to Market Maker Protection.
11511  {
11513 
11514  return enumeration<Boolean>(value, offset, NullUInt8());
11515  }
11516 
11517  /// Resets Market Protections. When Market Protections are
11518  /// triggered, the Exchange will not accept new orders for
11519  /// that product group without tag MMProtectionReset: True =
11520  /// Reset Market Maker Protection; False = Do nothing related
11521  /// to Market Maker Protection.
11524  {
11526 
11527  setEnumeration<Boolean>(offset, value);
11528  return *this;
11529  }
11530 
11533  {
11535 
11536  setOrdinary(offset, NullUInt8());
11537  return *this;
11538  }
11539 
11540  /// Client-assigned identification of a strategy.
11542  bool
11544  StrategyIDOptional& value) const
11546  {
11548 
11549  return ordinary(value, offset, NullStrategyIDOptional());
11550  }
11551 
11552  /// Client-assigned identification of a strategy.
11555  {
11557 
11558  setOrdinary(offset, value);
11559  return *this;
11560  }
11561 
11564  {
11566 
11567  setOrdinary(offset, NullStrategyIDOptional());
11568  return *this;
11569  }
11570 
11571  /// Account used for associating risk limits (when defined).
11575  {
11578 
11579  return ordinary(value, offset, NullAccountOptional(), since);
11580  }
11581 
11582  /// Account used for associating risk limits (when defined).
11584  {
11587 
11588  setOrdinary(offset, value, since);
11589  return *this;
11590  }
11591 
11593  {
11596 
11597  setOrdinary(offset, NullAccountOptional(), since);
11598  return *this;
11599  }
11600 
11601  /// Identifies the trading desk.
11603  StrRef deskId() const
11605  {
11606  return getVariableLengthField(deskIDAccess(), *this);
11607  }
11608 
11609  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
11611  StrRef memo() const
11613  {
11614  return getVariableLengthField(memoAccess(), *this);
11615  }
11616 
11617  /// Identifies the trading desk.
11618  ThisType& setDeskId(StrRef value)
11619  {
11620  setVariableLengthField(
11621  deskIDAccess(),
11622  value,
11623  *this);
11624 
11625  return *this;
11626  }
11627 
11628  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
11629  ThisType& setMemo(StrRef value)
11630  {
11631  setVariableLengthField(
11632  memoAccess(),
11633  value,
11634  *this);
11635 
11636  return *this;
11637  }
11638 
11639  /// Minimal size of message body in bytes.
11644  {
11645  return
11646  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
11647  (version >= 5)
11648  ? 190
11649  : (version >= 3)
11650  ? 186
11651  : 168;
11652  }
11653 
11654  /// Size of message body in bytes.
11657  static
11658  BlockLength
11662  {
11663  return
11664  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
11665  minimalBlockLength(version);
11666  }
11667 
11668  /// Minimal variable fields size (when variable-length fields are empty).
11672  static
11673  MessageSize
11676  {
11677  return
11678  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
11679  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
11680  }
11681 
11682  /// Maximal message size.
11686  static UInt64 getMaxMessageSize(UInt8)
11688  {
11689  return
11691  }
11692 
11693  /// Reset all variable-length fields if any.
11696  {
11697  setDeskIdToNull();
11698  setMemoToNull();
11699  return *this;
11700  }
11701 
11702  /// Reset all variable-length and optional fields if any.
11703  ThisType& reset()
11705  {
11706  setAccountToNull();
11707  setMarketSegmentReceivedTimeToNull();
11708  setOrigClOrdIdToNull();
11709  setProtectionPriceToNull();
11710  setMultiLegReportingTypeToNull();
11711  setExpireDateToNull();
11712  setPriceToNull();
11713  setStopPxToNull();
11714  setMinQtyToNull();
11715  setMaxFloorToNull();
11716  setReceivedTimeToNull();
11717  setOrdTagIdToNull();
11718  setInvestorIdToNull();
11719  setMmProtectionResetToNull();
11720  setStrategyIdToNull();
11721 
11722  if (version() >= 5)
11723  {
11724  setTradingSubAccountToNull();
11725  }
11726 
11727  resetVariableFields();
11728  return *this;
11729  }
11730 
11731  /// \return class name.
11735  static const Char* className()
11736  {
11737  return "ExecutionReportModify201";
11738  }
11739 
11740  /// FIX message type.
11744  static StrRef fixType()
11746  {
11747  return constructStrRef(
11748  "ExecutionReportModify201");
11749  }
11750 
11751  /// \return a human-readable presentation.
11753  std::string toString() const;
11754 
11755  /// \return the end of the message.
11757  const void* tail() const
11759  {
11760  return
11761  toOpaquePtr(
11762  (memo().end()));
11763  }
11764 
11765  /// \return the size occupied by the message.
11769  {
11770  return
11771  SbeMessage::calculateBinarySize(tail());
11772  }
11773 
11774 private:
11775  void checkLength(
11776  EncodedLength length, SchemaVersion version) const
11777  {
11778  const EncodedLength minimalRequiredLength =
11779  minimalBlockLength(version) +
11780  MessageHeader::Size +
11781  getMinimalVariableFieldsSize(version);
11782 
11783  checkBinaryLength(
11784  *this, length, minimalRequiredLength);
11785  }
11786 
11787  /// Checks variable fields consistency.
11788  void checkVarLenFields() const
11789  {
11790  variableLengthFields().
11791  checkTail<DeskIDEncoding>().
11792  checkTail<MemoEncoding>();
11793  }
11794 
11795  void checkCompatibility() const
11796  {
11797  assert(TemplateId == templateId());
11798 
11799  checkSchema<Schema>(schemaId(), version());
11800  checkLength(bufferSize(), version());
11801  checkVarLenFields();
11802  }
11803 
11804  /// Access helper.
11805  struct deskIDAccess
11806  {
11808  operator()(
11809  const ExecutionReportModify201& obj) const
11811  {
11812  return obj.
11813  variableLengthFields().
11814  head<DeskIDEncoding>();
11815  }
11816  };
11817 
11818  /// Access helper.
11819  struct memoAccess
11820  {
11821  MemoEncoding&
11822  operator()(
11823  const ExecutionReportModify201& obj) const
11825  {
11826  return obj.
11827  variableLengthFields().
11828  tail<DeskIDEncoding>().
11829  head<MemoEncoding>();
11830  }
11831  };
11832 
11833  /// Reset the field.
11834  /// All the following data will be invalidated.
11835  ThisType& setDeskIdToNull()
11837  {
11838  setVariableLengthFieldToNull(deskIDAccess(), *this);
11839 
11840  return *this;
11841  }
11842 
11843  /// Reset the field.
11844  /// All the following data will be invalidated.
11845  ThisType& setMemoToNull()
11847  {
11848  setVariableLengthFieldToNull(memoAccess(), *this);
11849 
11850  return *this;
11851  }
11852 };
11853 
11854 /// ExecutionReport - Cancel message is sent in response to Order Cancel Request as well as to report unsolicited cancellation of orders due to: Market Operations or Cancel On Disconnect mechanism.
11857 : SbeMessage
11858 {
11859  /// Used template schema.
11861 
11862  /// This type alias.
11864 
11865  /// Message template ID from SBE schema.
11866  enum { TemplateId = 202 };
11867 
11868  /// Initializes a blank instance.
11870 
11871  /// Initializes an instance over the given memory block.
11873  void* data,
11874  EncodedLength length,
11875  SchemaVersion version = Schema::Version)
11876  : SbeMessage(data, length, version)
11877  {
11878  checkVersion<Schema>(version);
11879  checkLength(length, version);
11880  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
11881  reset();
11882  }
11883 
11884  /// Initializes an instance over the given memory block
11885  /// With no variable-length fields initialization
11886  /// It is assumed that the user does such an initialization manually.
11888  void* data,
11889  EncodedLength length,
11890  NoFieldsInit,
11891  SchemaVersion version = Schema::Version)
11892  : SbeMessage(data, length, version)
11893  {
11894  checkVersion<Schema>(version);
11895  checkLength(length, version);
11896  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
11897  resetVariableFields();
11898  }
11899 
11900  /// Creates an instance over the given memory block.
11902  void* data,
11903  EncodedLength length,
11904  NoInit)
11905  : SbeMessage(data, length)
11906  {
11907  checkCompatibility();
11908  }
11909 
11910  /// Creates an instance over the given SBE message.
11911  explicit
11913  const SbeMessage& message)
11914  : SbeMessage(message)
11915  {
11916  assert(message.valid());
11917 
11918  checkCompatibility();
11919  }
11920 
11921  /// Creates an instance over the given memory block.
11922  /// Performs no checks.
11924  void* data,
11925  EncodedLength length,
11926  NoInit,
11927  NoCheck)
11929  : SbeMessage(data, length, NoCheck())
11930  {
11931  assert(schemaId() == Schema::Id);
11932  assert(version() >= Schema::MinimalVersion);
11933  assert(TemplateId == templateId());
11934  }
11935 
11936  /// MessageType.ExecutionReport_Cancel.
11941  {
11942  return MessageType::ExecutionReportCancel;
11943  }
11944 
11945  /// MessageType.ExecutionReport_Cancel.
11946 
11947  /// Common header to all outbound business messages.
11949  const OutboundBusinessHeader&
11952  {
11954 
11955  return accessOrdinary<OutboundBusinessHeader>(offset);
11956  }
11957 
11958  /// Common header to all outbound business messages.
11961  {
11963  return accessOrdinary<OutboundBusinessHeader>(offset);
11964  }
11965 
11966  /// Side of order.
11970  {
11972 
11973  return enumeration<Side>(offset);
11974  }
11975 
11976  /// Side of order.
11977  ThisType& setSide(Side::Enum value)
11979  {
11981 
11982  setEnumeration<Side>(offset, value);
11983  return *this;
11984  }
11985 
11986  /// Identifies current status of order.
11990  {
11992 
11993  return enumeration<OrdStatus>(offset);
11994  }
11995 
11996  /// Identifies current status of order.
11999  {
12001 
12002  setEnumeration<OrdStatus>(offset, value);
12003  return *this;
12004  }
12005 
12006  /// Unique identifier of the order as assigned by the market
12007  /// participant.
12011  {
12013 
12014  return ordinary<ClOrdID>(offset);
12015  }
12016 
12017  /// Unique identifier of the order as assigned by the market
12018  /// participant.
12019  ThisType& setClOrdId(ClOrdID value)
12021  {
12023 
12024  setOrdinary(offset, value);
12025  return *this;
12026  }
12027 
12028  /// Exchange-generated order identifier that changes for each
12029  /// order modification event, or quantity replenishment in
12030  /// disclosed orders.
12034  {
12036 
12037  return ordinary<OrderID>(offset);
12038  }
12039 
12040  /// Exchange-generated order identifier that changes for each
12041  /// order modification event, or quantity replenishment in
12042  /// disclosed orders.
12043  ThisType& setSecondaryOrderId(OrderID value)
12045  {
12047 
12048  setOrdinary(offset, value);
12049  return *this;
12050  }
12051 
12052  /// Security identification as defined by exchange.
12056  {
12058 
12059  return ordinary<SecurityID>(offset);
12060  }
12061 
12062  /// Security identification as defined by exchange.
12063  ThisType& setSecurityId(SecurityID value)
12065  {
12067 
12068  setOrdinary(offset, value);
12069  return *this;
12070  }
12071 
12072  /// Identifies the class of the SecurityID (Exchange Symbol).
12077  {
12078  return SecurityIDSource::ExchangeSymbol;
12079  }
12080 
12081  /// Identifies the class of the SecurityID (Exchange Symbol).
12082 
12083  /// Market to which the symbol belongs.
12089  {
12090  return constructStrRef("BVMF");
12091  }
12092 
12093  /// Total number of shares or contracts filled.
12097  {
12099 
12100  return ordinary<Quantity>(offset);
12101  }
12102 
12103  /// Total number of shares or contracts filled.
12104  ThisType& setCumQty(Quantity value)
12106  {
12108 
12109  setOrdinary(offset, value);
12110  return *this;
12111  }
12112 
12113  /// Account mnemonic of the order.
12115  bool account(AccountOptional& value) const
12117  {
12119 
12120  return ordinary(value, offset, NullAccountOptional());
12121  }
12122 
12123  /// Account mnemonic of the order.
12124  ThisType& setAccount(AccountOptional value)
12126  {
12128 
12129  setOrdinary(offset, value);
12130  return *this;
12131  }
12132 
12133  ThisType& setAccountToNull()
12135  {
12137 
12138  setOrdinary(offset, NullAccountOptional());
12139  return *this;
12140  }
12141 
12142  /// Unique identifier of execution message as assigned by the
12143  /// exchange – unique per instrument.
12145  ExecID execId() const
12147  {
12149 
12150  return ordinary<ExecID>(offset);
12151  }
12152 
12153  /// Unique identifier of execution message as assigned by the
12154  /// exchange – unique per instrument.
12155  ThisType& setExecId(ExecID value)
12157  {
12159 
12160  setOrdinary(offset, value);
12161  return *this;
12162  }
12163 
12164  /// Time of execution/order creation.
12168  {
12170 
12171  return ordinary<UTCTimestampNanos>(offset);
12172  }
12173 
12174  /// Time of execution/order creation.
12177  {
12179 
12180  setOrdinary(offset, value);
12181  return *this;
12182  }
12183 
12184  /// Time of receipt of related inbound message in the market
12185  /// segment path. For aggressor STOP orders, it indicates the
12186  /// moment when the order is triggered.
12188  bool
12190  UTCTimestampNanosOptional& value) const
12192  {
12194 
12195  return ordinary(value, offset, NullUTCTimestampNanosOptional());
12196  }
12197 
12198  /// Time of receipt of related inbound message in the market
12199  /// segment path. For aggressor STOP orders, it indicates the
12200  /// moment when the order is triggered.
12201  ThisType&
12205  {
12207 
12208  setOrdinary(offset, value);
12209  return *this;
12210  }
12211 
12214  {
12216 
12217  setOrdinary(offset, NullUTCTimestampNanosOptional());
12218  return *this;
12219  }
12220 
12221  /// Unique identifier for order as assigned by the exchange.
12225  {
12227 
12228  return ordinary<OrderID>(offset);
12229  }
12230 
12231  /// Unique identifier for order as assigned by the exchange.
12232  ThisType& setOrderId(OrderID value)
12234  {
12236 
12237  setOrdinary(offset, value);
12238  return *this;
12239  }
12240 
12241  /// Value of origClOrdID field informed from the related
12242  /// request message.
12244  bool origClOrdId(ClOrdIDOptional& value) const
12246  {
12248 
12249  return ordinary(value, offset, NullClOrdIDOptional());
12250  }
12251 
12252  /// Value of origClOrdID field informed from the related
12253  /// request message.
12256  {
12258 
12259  setOrdinary(offset, value);
12260  return *this;
12261  }
12262 
12265  {
12267 
12268  setOrdinary(offset, NullClOrdIDOptional());
12269  return *this;
12270  }
12271 
12272  /// Indicates date of trading day (expressed in local time at
12273  /// place of trade). Sent in number of days since Unix epoch.
12277  {
12279 
12280  return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
12281  }
12282 
12283  /// Indicates date of trading day (expressed in local time at
12284  /// place of trade). Sent in number of days since Unix epoch.
12285  ThisType& setTradeDate(Timestamp value)
12287  {
12289 
12290  setOrdinary(offset, timestampToLocalMktDate(value));
12291  return *this;
12292  }
12293 
12294  /// Indicates if an order has been triggered and is available
12295  /// for trading. Used with Stop (Limit, with protection)
12296  /// orders and the At the Close validity.
12300  {
12302 
12303  return enumeration<Boolean>(offset);
12304  }
12305 
12306  /// Indicates if an order has been triggered and is available
12307  /// for trading. Used with Stop (Limit, with protection)
12308  /// orders and the At the Close validity.
12311  {
12313 
12314  setEnumeration<Boolean>(offset, value);
12315  return *this;
12316  }
12317 
12318  /// Indicates reason of cancelation, if available.
12320  bool
12322  ExecRestatementReason::Enum& value) const
12324  {
12326 
12327  return enumeration<ExecRestatementReason>(value, offset, NullUint8EnumEncoding());
12328  }
12329 
12330  /// Indicates reason of cancelation, if available.
12331  ThisType&
12335  {
12337 
12338  setEnumeration<ExecRestatementReason>(offset, value);
12339  return *this;
12340  }
12341 
12344  {
12346 
12347  setOrdinary(offset, NullUint8EnumEncoding());
12348  return *this;
12349  }
12350 
12351  /// Unique ID of Order Mass Action Report as assigned by the
12352  /// matching engine.
12354  bool
12356  MassActionReportIDOptional& value) const
12358  {
12360 
12361  return ordinary(value, offset, NullMassActionReportIDOptional());
12362  }
12363 
12364  /// Unique ID of Order Mass Action Report as assigned by the
12365  /// matching engine.
12366  ThisType&
12370  {
12372 
12373  setOrdinary(offset, value);
12374  return *this;
12375  }
12376 
12379  {
12381 
12382  setOrdinary(offset, NullMassActionReportIDOptional());
12383  return *this;
12384  }
12385 
12386  /// Order type.
12390  {
12392 
12393  return enumeration<OrdType>(offset);
12394  }
12395 
12396  /// Order type.
12397  ThisType& setOrdType(OrdType::Enum value)
12399  {
12401 
12402  setEnumeration<OrdType>(offset, value);
12403  return *this;
12404  }
12405 
12406  /// Specifies how long the order remains in effect.
12410  {
12412 
12413  return enumeration<TimeInForce>(offset);
12414  }
12415 
12416  /// Specifies how long the order remains in effect.
12419  {
12421 
12422  setEnumeration<TimeInForce>(offset, value);
12423  return *this;
12424  }
12425 
12426  /// Date of order expiration (last day the order can trade),
12427  /// always expressed in terms of the local market date.
12429  bool expireDate(Timestamp& value) const
12431  {
12432  typedef LocalMktDateOptional FieldValue;
12433 
12435 
12436  FieldValue fieldValue;
12437 
12438  if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
12439  {
12440  value = localMktDateToTimestamp(fieldValue);
12441  return true;
12442  }
12443  return false;
12444  }
12445 
12446  /// Date of order expiration (last day the order can trade),
12447  /// always expressed in terms of the local market date.
12448  ThisType& setExpireDate(Timestamp value)
12450  {
12452 
12453  setOrdinary(offset, timestampToLocalMktDate(value));
12454  return *this;
12455  }
12456 
12459  {
12461 
12462  setOrdinary(offset, NullLocalMktDateOptional());
12463  return *this;
12464  }
12465 
12466  /// Quantity ordered.
12470  {
12472 
12473  return ordinary<Quantity>(offset);
12474  }
12475 
12476  /// Quantity ordered.
12477  ThisType& setOrderQty(Quantity value)
12479  {
12481 
12482  setOrdinary(offset, value);
12483  return *this;
12484  }
12485 
12486  /// Price per share or contract. Conditionally required if the
12487  /// order type requires a price (not market orders and RLP).
12489  bool price(PriceOptional& value) const
12491  {
12493 
12494  return decimal(value, offset, NullPriceOptional());
12495  }
12496 
12497  /// Price per share or contract. Conditionally required if the
12498  /// order type requires a price (not market orders and RLP).
12499  ThisType& setPrice(PriceOptional value)
12501  {
12503 
12504  setOrdinary(offset, value);
12505  return *this;
12506  }
12507 
12508  ThisType& setPriceToNull()
12510  {
12512 
12513  setOrdinary(offset, NullPriceOptional());
12514  return *this;
12515  }
12516 
12517  /// The stop price of a stop limit order (Conditionally
12518  /// required if OrdType = 4).
12520  bool stopPx(PriceOptional& value) const
12522  {
12524 
12525  return decimal(value, offset, NullPriceOptional());
12526  }
12527 
12528  /// The stop price of a stop limit order (Conditionally
12529  /// required if OrdType = 4).
12530  ThisType& setStopPx(PriceOptional value)
12532  {
12534 
12535  setOrdinary(offset, value);
12536  return *this;
12537  }
12538 
12539  ThisType& setStopPxToNull()
12541  {
12543 
12544  setOrdinary(offset, NullPriceOptional());
12545  return *this;
12546  }
12547 
12548  /// Minimum quantity of an order to be executed.
12550  bool minQty(QuantityOptional& value) const
12552  {
12554 
12555  return ordinary(value, offset, NullQuantityOptional());
12556  }
12557 
12558  /// Minimum quantity of an order to be executed.
12559  ThisType& setMinQty(QuantityOptional value)
12561  {
12563 
12564  setOrdinary(offset, value);
12565  return *this;
12566  }
12567 
12568  ThisType& setMinQtyToNull()
12570  {
12572 
12573  setOrdinary(offset, NullQuantityOptional());
12574  return *this;
12575  }
12576 
12577  /// Maximum number of shares or contracts within an order to
12578  /// be shown on the match engine at any given time.
12580  bool maxFloor(QuantityOptional& value) const
12582  {
12584 
12585  return ordinary(value, offset, NullQuantityOptional());
12586  }
12587 
12588  /// Maximum number of shares or contracts within an order to
12589  /// be shown on the match engine at any given time.
12592  {
12594 
12595  setOrdinary(offset, value);
12596  return *this;
12597  }
12598 
12599  ThisType& setMaxFloorToNull()
12601  {
12603 
12604  setOrdinary(offset, NullQuantityOptional());
12605  return *this;
12606  }
12607 
12608  /// Time of receipt of related inbound message in the gateway.
12610  bool
12612  UTCTimestampNanosOptional& value) const
12614  {
12616 
12617  return ordinary(value, offset, NullUTCTimestampNanosOptional());
12618  }
12619 
12620  /// Time of receipt of related inbound message in the gateway.
12621  ThisType&
12625  {
12627 
12628  setOrdinary(offset, value);
12629  return *this;
12630  }
12631 
12634  {
12636 
12637  setOrdinary(offset, NullUTCTimestampNanosOptional());
12638  return *this;
12639  }
12640 
12641  /// Identifies the order tag identification.
12643  bool ordTagId(OrdTagID& value) const
12645  {
12647 
12648  return ordinary(value, offset, NullOrdTagID());
12649  }
12650 
12651  /// Identifies the order tag identification.
12652  ThisType& setOrdTagId(OrdTagID value)
12654  {
12656 
12657  setOrdinary(offset, value);
12658  return *this;
12659  }
12660 
12661  ThisType& setOrdTagIdToNull()
12663  {
12665 
12666  setOrdinary(offset, NullOrdTagID());
12667  return *this;
12668  }
12669 
12670  /// Unique identifier of investor for self trade
12671  /// prevention/mass cancel on behalf purposes.
12673  bool investorId(InvestorID& value) const
12675  {
12677 
12678  return ordinary(value, offset, NullInvestorID());
12679  }
12680 
12681  /// Unique identifier of investor for self trade
12682  /// prevention/mass cancel on behalf purposes.
12683  ThisType& setInvestorId(InvestorID value)
12685  {
12687 
12688  setOrdinary(offset, value);
12689  return *this;
12690  }
12691 
12694  {
12696 
12697  setOrdinary(offset, NullInvestorID());
12698  return *this;
12699  }
12700 
12701  /// Client-assigned identification of a strategy.
12703  bool
12705  StrategyIDOptional& value) const
12707  {
12709 
12710  return ordinary(value, offset, NullStrategyIDOptional());
12711  }
12712 
12713  /// Client-assigned identification of a strategy.
12716  {
12718 
12719  setOrdinary(offset, value);
12720  return *this;
12721  }
12722 
12725  {
12727 
12728  setOrdinary(offset, NullStrategyIDOptional());
12729  return *this;
12730  }
12731 
12732  /// Indicates the SessionID that requested the Cancel on
12733  /// behalf.
12737  {
12739 
12740  return ordinary(value, offset, NullSessionIDOptional());
12741  }
12742 
12743  /// Indicates the SessionID that requested the Cancel on
12744  /// behalf.
12747  {
12749 
12750  setOrdinary(offset, value);
12751  return *this;
12752  }
12753 
12756  {
12758 
12759  setOrdinary(offset, NullSessionIDOptional());
12760  return *this;
12761  }
12762 
12763  /// Identifies the trading desk.
12765  StrRef deskId() const
12767  {
12768  return getVariableLengthField(deskIDAccess(), *this);
12769  }
12770 
12771  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
12773  StrRef memo() const
12775  {
12776  return getVariableLengthField(memoAccess(), *this);
12777  }
12778 
12779  /// Identifies the trading desk.
12780  ThisType& setDeskId(StrRef value)
12781  {
12782  setVariableLengthField(
12783  deskIDAccess(),
12784  value,
12785  *this);
12786 
12787  return *this;
12788  }
12789 
12790  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
12791  ThisType& setMemo(StrRef value)
12792  {
12793  setVariableLengthField(
12794  memoAccess(),
12795  value,
12796  *this);
12797 
12798  return *this;
12799  }
12800 
12801  /// Minimal size of message body in bytes.
12806  {
12807  return
12808  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
12809  (version >= 3)
12810  ? 184
12811  : 164;
12812  }
12813 
12814  /// Size of message body in bytes.
12817  static
12818  BlockLength
12822  {
12823  return
12824  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
12825  minimalBlockLength(version);
12826  }
12827 
12828  /// Minimal variable fields size (when variable-length fields are empty).
12832  static
12833  MessageSize
12836  {
12837  return
12838  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
12839  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
12840  }
12841 
12842  /// Maximal message size.
12846  static UInt64 getMaxMessageSize(UInt8)
12848  {
12849  return
12851  }
12852 
12853  /// Reset all variable-length fields if any.
12856  {
12857  setDeskIdToNull();
12858  setMemoToNull();
12859  return *this;
12860  }
12861 
12862  /// Reset all variable-length and optional fields if any.
12863  ThisType& reset()
12865  {
12866  setAccountToNull();
12867  setMarketSegmentReceivedTimeToNull();
12868  setOrigClOrdIdToNull();
12869  setExecRestatementReasonToNull();
12870  setMassActionReportIdToNull();
12871  setExpireDateToNull();
12872  setPriceToNull();
12873  setStopPxToNull();
12874  setMinQtyToNull();
12875  setMaxFloorToNull();
12876  setReceivedTimeToNull();
12877  setOrdTagIdToNull();
12878  setInvestorIdToNull();
12879  setStrategyIdToNull();
12880  setActionRequestedFromSessionIdToNull();
12881 
12882  resetVariableFields();
12883  return *this;
12884  }
12885 
12886  /// \return class name.
12890  static const Char* className()
12891  {
12892  return "ExecutionReportCancel202";
12893  }
12894 
12895  /// FIX message type.
12899  static StrRef fixType()
12901  {
12902  return constructStrRef(
12903  "ExecutionReportCancel202");
12904  }
12905 
12906  /// \return a human-readable presentation.
12908  std::string toString() const;
12909 
12910  /// \return the end of the message.
12912  const void* tail() const
12914  {
12915  return
12916  toOpaquePtr(
12917  (memo().end()));
12918  }
12919 
12920  /// \return the size occupied by the message.
12924  {
12925  return
12926  SbeMessage::calculateBinarySize(tail());
12927  }
12928 
12929 private:
12930  void checkLength(
12931  EncodedLength length, SchemaVersion version) const
12932  {
12933  const EncodedLength minimalRequiredLength =
12934  minimalBlockLength(version) +
12935  MessageHeader::Size +
12936  getMinimalVariableFieldsSize(version);
12937 
12938  checkBinaryLength(
12939  *this, length, minimalRequiredLength);
12940  }
12941 
12942  /// Checks variable fields consistency.
12943  void checkVarLenFields() const
12944  {
12945  variableLengthFields().
12946  checkTail<DeskIDEncoding>().
12947  checkTail<MemoEncoding>();
12948  }
12949 
12950  void checkCompatibility() const
12951  {
12952  assert(TemplateId == templateId());
12953 
12954  checkSchema<Schema>(schemaId(), version());
12955  checkLength(bufferSize(), version());
12956  checkVarLenFields();
12957  }
12958 
12959  /// Access helper.
12960  struct deskIDAccess
12961  {
12963  operator()(
12964  const ExecutionReportCancel202& obj) const
12966  {
12967  return obj.
12968  variableLengthFields().
12969  head<DeskIDEncoding>();
12970  }
12971  };
12972 
12973  /// Access helper.
12974  struct memoAccess
12975  {
12976  MemoEncoding&
12977  operator()(
12978  const ExecutionReportCancel202& obj) const
12980  {
12981  return obj.
12982  variableLengthFields().
12983  tail<DeskIDEncoding>().
12984  head<MemoEncoding>();
12985  }
12986  };
12987 
12988  /// Reset the field.
12989  /// All the following data will be invalidated.
12990  ThisType& setDeskIdToNull()
12992  {
12993  setVariableLengthFieldToNull(deskIDAccess(), *this);
12994 
12995  return *this;
12996  }
12997 
12998  /// Reset the field.
12999  /// All the following data will be invalidated.
13000  ThisType& setMemoToNull()
13002  {
13003  setVariableLengthFieldToNull(memoAccess(), *this);
13004 
13005  return *this;
13006  }
13007 };
13008 
13009 /// Execution Report – Trade/Trade Bust message is sent with order fills that were traded and processed on Matching Engine. Also, trade bust included on behalf of B3’s desk.
13012 : SbeMessage
13013 {
13014  /// Used template schema.
13016 
13017  /// This type alias.
13019 
13020  /// Message template ID from SBE schema.
13021  enum { TemplateId = 203 };
13022 
13023  /// Initializes a blank instance.
13025 
13026  /// Initializes an instance over the given memory block.
13028  void* data,
13029  EncodedLength length,
13030  SchemaVersion version = Schema::Version)
13031  : SbeMessage(data, length, version)
13032  {
13033  checkVersion<Schema>(version);
13034  checkLength(length, version);
13035  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
13036  reset();
13037  }
13038 
13039  /// Initializes an instance over the given memory block
13040  /// With no variable-length fields initialization
13041  /// It is assumed that the user does such an initialization manually.
13043  void* data,
13044  EncodedLength length,
13045  NoFieldsInit,
13046  SchemaVersion version = Schema::Version)
13047  : SbeMessage(data, length, version)
13048  {
13049  checkVersion<Schema>(version);
13050  checkLength(length, version);
13051  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
13052  resetVariableFields();
13053  }
13054 
13055  /// Creates an instance over the given memory block.
13057  void* data,
13058  EncodedLength length,
13059  NoInit)
13060  : SbeMessage(data, length)
13061  {
13062  checkCompatibility();
13063  }
13064 
13065  /// Creates an instance over the given SBE message.
13066  explicit
13068  const SbeMessage& message)
13069  : SbeMessage(message)
13070  {
13071  assert(message.valid());
13072 
13073  checkCompatibility();
13074  }
13075 
13076  /// Creates an instance over the given memory block.
13077  /// Performs no checks.
13079  void* data,
13080  EncodedLength length,
13081  NoInit,
13082  NoCheck)
13084  : SbeMessage(data, length, NoCheck())
13085  {
13086  assert(schemaId() == Schema::Id);
13087  assert(version() >= Schema::MinimalVersion);
13088  assert(TemplateId == templateId());
13089  }
13090 
13091  /// MessageType.ExecutionReport_Trade.
13096  {
13097  return MessageType::ExecutionReportTrade;
13098  }
13099 
13100  /// MessageType.ExecutionReport_Trade.
13101 
13102  /// Common header to all outbound business messages.
13104  const OutboundBusinessHeader&
13107  {
13109 
13110  return accessOrdinary<OutboundBusinessHeader>(offset);
13111  }
13112 
13113  /// Common header to all outbound business messages.
13116  {
13118  return accessOrdinary<OutboundBusinessHeader>(offset);
13119  }
13120 
13121  /// Side of order.
13125  {
13127 
13128  return enumeration<Side>(offset);
13129  }
13130 
13131  /// Side of order.
13132  ThisType& setSide(Side::Enum value)
13134  {
13136 
13137  setEnumeration<Side>(offset, value);
13138  return *this;
13139  }
13140 
13141  /// Identifies current status of order.
13145  {
13147 
13148  return enumeration<OrdStatus>(offset);
13149  }
13150 
13151  /// Identifies current status of order.
13154  {
13156 
13157  setEnumeration<OrdStatus>(offset, value);
13158  return *this;
13159  }
13160 
13161  /// Unique identifier of the order as assigned by the market
13162  /// participant.
13164  bool clOrdId(ClOrdIDOptional& value) const
13166  {
13168 
13169  return ordinary(value, offset, NullClOrdIDOptional());
13170  }
13171 
13172  /// Unique identifier of the order as assigned by the market
13173  /// participant.
13174  ThisType& setClOrdId(ClOrdIDOptional value)
13176  {
13178 
13179  setOrdinary(offset, value);
13180  return *this;
13181  }
13182 
13183  ThisType& setClOrdIdToNull()
13185  {
13187 
13188  setOrdinary(offset, NullClOrdIDOptional());
13189  return *this;
13190  }
13191 
13192  /// Exchange-generated order identifier that changes for each
13193  /// order modification event, or quantity replenishment in
13194  /// disclosed orders.
13198  {
13200 
13201  return ordinary<OrderID>(offset);
13202  }
13203 
13204  /// Exchange-generated order identifier that changes for each
13205  /// order modification event, or quantity replenishment in
13206  /// disclosed orders.
13207  ThisType& setSecondaryOrderId(OrderID value)
13209  {
13211 
13212  setOrdinary(offset, value);
13213  return *this;
13214  }
13215 
13216  /// Security identification as defined by exchange.
13220  {
13222 
13223  return ordinary<SecurityID>(offset);
13224  }
13225 
13226  /// Security identification as defined by exchange.
13227  ThisType& setSecurityId(SecurityID value)
13229  {
13231 
13232  setOrdinary(offset, value);
13233  return *this;
13234  }
13235 
13236  /// Identifies the class of the SecurityID (Exchange Symbol).
13241  {
13242  return SecurityIDSource::ExchangeSymbol;
13243  }
13244 
13245  /// Identifies the class of the SecurityID (Exchange Symbol).
13246 
13247  /// Market to which the symbol belongs.
13253  {
13254  return constructStrRef("BVMF");
13255  }
13256 
13257  /// Account mnemonic of the order.
13259  bool account(AccountOptional& value) const
13261  {
13263 
13264  return ordinary(value, offset, NullAccountOptional());
13265  }
13266 
13267  /// Account mnemonic of the order.
13268  ThisType& setAccount(AccountOptional value)
13270  {
13272 
13273  setOrdinary(offset, value);
13274  return *this;
13275  }
13276 
13277  ThisType& setAccountToNull()
13279  {
13281 
13282  setOrdinary(offset, NullAccountOptional());
13283  return *this;
13284  }
13285 
13286  /// Quantity of shares bought/sold on the last fill.
13290  {
13292 
13293  return ordinary<Quantity>(offset);
13294  }
13295 
13296  /// Quantity of shares bought/sold on the last fill.
13297  ThisType& setLastQty(Quantity value)
13299  {
13301 
13302  setOrdinary(offset, value);
13303  return *this;
13304  }
13305 
13306  /// Price of last fill.
13308  Price lastPx() const
13310  {
13312 
13313  return decimal<Price>(offset);
13314  }
13315 
13316  /// Price of last fill.
13317  ThisType& setLastPx(Price value)
13319  {
13321 
13322  setOrdinary(offset, value);
13323  return *this;
13324  }
13325 
13326  /// Unique identifier of execution message as assigned by the
13327  /// exchange – unique per instrument.
13329  ExecID execId() const
13331  {
13333 
13334  return ordinary<ExecID>(offset);
13335  }
13336 
13337  /// Unique identifier of execution message as assigned by the
13338  /// exchange – unique per instrument.
13339  ThisType& setExecId(ExecID value)
13341  {
13343 
13344  setOrdinary(offset, value);
13345  return *this;
13346  }
13347 
13348  /// Time of execution/order creation.
13352  {
13354 
13355  return ordinary<UTCTimestampNanos>(offset);
13356  }
13357 
13358  /// Time of execution/order creation.
13361  {
13363 
13364  setOrdinary(offset, value);
13365  return *this;
13366  }
13367 
13368  /// Amount of shares open for further execution, or
13369  /// unexecuted.
13373  {
13375 
13376  return ordinary<Quantity>(offset);
13377  }
13378 
13379  /// Amount of shares open for further execution, or
13380  /// unexecuted.
13381  ThisType& setLeavesQty(Quantity value)
13383  {
13385 
13386  setOrdinary(offset, value);
13387  return *this;
13388  }
13389 
13390  /// Total number of shares or contracts filled.
13394  {
13396 
13397  return ordinary<Quantity>(offset);
13398  }
13399 
13400  /// Total number of shares or contracts filled.
13401  ThisType& setCumQty(Quantity value)
13403  {
13405 
13406  setOrdinary(offset, value);
13407  return *this;
13408  }
13409 
13410  /// Identify whether the order initiator is an aggressor or
13411  /// not in the trade.
13415  {
13417 
13418  return enumeration<Boolean>(offset);
13419  }
13420 
13421  /// Identify whether the order initiator is an aggressor or
13422  /// not in the trade.
13425  {
13427 
13428  setEnumeration<Boolean>(offset, value);
13429  return *this;
13430  }
13431 
13432  /// Describes the action that triggered this specific
13433  /// Execution Report - see the OrdStatus (39) tag for the
13434  /// current order status (e.g, Partially Filled).
13438  {
13440 
13441  return enumeration<ExecType>(offset);
13442  }
13443 
13444  /// Describes the action that triggered this specific
13445  /// Execution Report - see the OrdStatus (39) tag for the
13446  /// current order status (e.g, Partially Filled).
13447  ThisType& setExecType(ExecType::Enum value)
13449  {
13451 
13452  setEnumeration<ExecType>(offset, value);
13453  return *this;
13454  }
13455 
13456  /// Reason why a trade occurred.
13458  bool
13460  OrderCategory::Enum& value) const
13462  {
13464 
13465  return enumeration<OrderCategory>(value, offset, NullChar());
13466  }
13467 
13468  /// Reason why a trade occurred.
13469  ThisType&
13471  OrderCategory::Enum value)
13473  {
13475 
13476  setEnumeration<OrderCategory>(offset, value);
13477  return *this;
13478  }
13479 
13482  {
13484 
13485  setOrdinary(offset, NullChar());
13486  return *this;
13487  }
13488 
13489  /// Used to indicate what an Execution Report represents.
13490  /// Default value is 1 (Single Security).
13492  bool
13494  MultiLegReportingType::Enum& value) const
13496  {
13498 
13499  return enumeration<MultiLegReportingType>(value, offset, NullChar());
13500  }
13501 
13502  /// Used to indicate what an Execution Report represents.
13503  /// Default value is 1 (Single Security).
13504  ThisType&
13508  {
13510 
13511  setEnumeration<MultiLegReportingType>(offset, value);
13512  return *this;
13513  }
13514 
13517  {
13519 
13520  setOrdinary(offset, NullChar());
13521  return *this;
13522  }
13523 
13524  /// Contains the unique identifier for this trade, per
13525  /// instrument + trading date, as assigned by the exchange.
13529  {
13531 
13532  return ordinary<TradeID>(offset);
13533  }
13534 
13535  /// Contains the unique identifier for this trade, per
13536  /// instrument + trading date, as assigned by the exchange.
13537  ThisType& setTradeId(TradeID value)
13539  {
13541 
13542  setOrdinary(offset, value);
13543  return *this;
13544  }
13545 
13546  /// Identifies the contra broker firm.
13550  {
13552 
13553  return ordinary<Firm>(offset);
13554  }
13555 
13556  /// Identifies the contra broker firm.
13557  ThisType& setContraBroker(Firm value)
13559  {
13561 
13562  setOrdinary(offset, value);
13563  return *this;
13564  }
13565 
13566  /// Unique identifier for order as assigned by the exchange.
13570  {
13572 
13573  return ordinary<OrderID>(offset);
13574  }
13575 
13576  /// Unique identifier for order as assigned by the exchange.
13577  ThisType& setOrderId(OrderID value)
13579  {
13581 
13582  setOrdinary(offset, value);
13583  return *this;
13584  }
13585 
13586  /// Indicates date of trading day (expressed in local time at
13587  /// place of trade). Sent in number of days since Unix epoch.
13591  {
13593 
13594  return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
13595  }
13596 
13597  /// Indicates date of trading day (expressed in local time at
13598  /// place of trade). Sent in number of days since Unix epoch.
13599  ThisType& setTradeDate(Timestamp value)
13601  {
13603 
13604  setOrdinary(offset, timestampToLocalMktDate(value));
13605  return *this;
13606  }
13607 
13608  /// Number of leg fill notice messages sent with spread
13609  /// summary.
13613  {
13615 
13616  return ordinary(value, offset, NullTotNoRelatedSym());
13617  }
13618 
13619  /// Number of leg fill notice messages sent with spread
13620  /// summary.
13623  {
13625 
13626  setOrdinary(offset, value);
13627  return *this;
13628  }
13629 
13632  {
13634 
13635  setOrdinary(offset, NullTotNoRelatedSym());
13636  return *this;
13637  }
13638 
13639  /// Unique identifier present in all messages associated with
13640  /// a spread transaction. This value allows linking spread
13641  /// summary fill notice, leg fill notices, and leg trade
13642  /// cancellation execution report messages generated from a
13643  /// spread transaction.
13645  bool secondaryExecId(ExecIDOptional& value) const
13647  {
13649 
13650  return ordinary(value, offset, NullExecIDOptional());
13651  }
13652 
13653  /// Unique identifier present in all messages associated with
13654  /// a spread transaction. This value allows linking spread
13655  /// summary fill notice, leg fill notices, and leg trade
13656  /// cancellation execution report messages generated from a
13657  /// spread transaction.
13660  {
13662 
13663  setOrdinary(offset, value);
13664  return *this;
13665  }
13666 
13669  {
13671 
13672  setOrdinary(offset, NullExecIDOptional());
13673  return *this;
13674  }
13675 
13676  /// Optionally sent when reporting a trade bust. Contains the
13677  /// identifier of the busted trade.
13679  bool execRefId(ExecIDOptional& value) const
13681  {
13683 
13684  return ordinary(value, offset, NullExecIDOptional());
13685  }
13686 
13687  /// Optionally sent when reporting a trade bust. Contains the
13688  /// identifier of the busted trade.
13689  ThisType& setExecRefId(ExecIDOptional value)
13691  {
13693 
13694  setOrdinary(offset, value);
13695  return *this;
13696  }
13697 
13700  {
13702 
13703  setOrdinary(offset, NullExecIDOptional());
13704  return *this;
13705  }
13706 
13707  /// ID of electronically submitted cross order by the
13708  /// institution (if in response to a cross order).
13710  bool crossId(CrossIDOptional& value) const
13712  {
13714 
13715  return ordinary(value, offset, NullCrossIDOptional());
13716  }
13717 
13718  /// ID of electronically submitted cross order by the
13719  /// institution (if in response to a cross order).
13720  ThisType& setCrossId(CrossIDOptional value)
13722  {
13724 
13725  setOrdinary(offset, value);
13726  return *this;
13727  }
13728 
13729  ThisType& setCrossIdToNull()
13731  {
13733 
13734  setOrdinary(offset, NullCrossIDOptional());
13735  return *this;
13736  }
13737 
13738  /// Indicates cross order purpose.
13740  bool
13742  CrossedIndicator::Enum& value) const
13744  {
13746 
13747  return enumeration<CrossedIndicator>(value, offset, NullUint16EnumEncoding());
13748  }
13749 
13750  /// Indicates cross order purpose.
13751  ThisType&
13753  CrossedIndicator::Enum value)
13755  {
13757 
13758  setEnumeration<CrossedIndicator>(offset, value);
13759  return *this;
13760  }
13761 
13764  {
13766 
13767  setOrdinary(offset, NullUint16EnumEncoding());
13768  return *this;
13769  }
13770 
13771  /// Quantity ordered.
13775  {
13777 
13778  return ordinary<Quantity>(offset);
13779  }
13780 
13781  /// Quantity ordered.
13782  ThisType& setOrderQty(Quantity value)
13784  {
13786 
13787  setOrdinary(offset, value);
13788  return *this;
13789  }
13790 
13791  /// Identifier for Trading Session.
13793  bool
13795  TradingSessionID::Enum& value) const
13797  {
13799 
13800  return enumeration<TradingSessionID>(value, offset, NullUint8EnumEncoding());
13801  }
13802 
13803  /// Identifier for Trading Session.
13804  ThisType&
13806  TradingSessionID::Enum value)
13808  {
13810 
13811  setEnumeration<TradingSessionID>(offset, value);
13812  return *this;
13813  }
13814 
13817  {
13819 
13820  setOrdinary(offset, NullUint8EnumEncoding());
13821  return *this;
13822  }
13823 
13824  /// Identifier for the instrument group phase.
13826  bool
13828  TradingSessionSubID::Enum& value) const
13830  {
13832 
13833  return enumeration<TradingSessionSubID>(value, offset, NullUint8EnumEncoding());
13834  }
13835 
13836  /// Identifier for the instrument group phase.
13837  ThisType&
13841  {
13843 
13844  setEnumeration<TradingSessionSubID>(offset, value);
13845  return *this;
13846  }
13847 
13850  {
13852 
13853  setOrdinary(offset, NullUint8EnumEncoding());
13854  return *this;
13855  }
13856 
13857  /// Identifier for the instrument status.
13859  bool
13861  SecurityTradingStatus::Enum& value) const
13863  {
13865 
13866  return enumeration<SecurityTradingStatus>(value, offset, NullUint8EnumEncoding());
13867  }
13868 
13869  /// Identifier for the instrument status.
13870  ThisType&
13874  {
13876 
13877  setEnumeration<SecurityTradingStatus>(offset, value);
13878  return *this;
13879  }
13880 
13883  {
13885 
13886  setOrdinary(offset, NullUint8EnumEncoding());
13887  return *this;
13888  }
13889 
13890  /// Type of cross being submitted to a market. Null value
13891  /// indicates report is not related to cross.
13893  bool crossType(CrossType::Enum& value) const
13895  {
13897 
13898  return enumeration<CrossType>(value, offset, NullUint8EnumEncoding());
13899  }
13900 
13901  /// Type of cross being submitted to a market. Null value
13902  /// indicates report is not related to cross.
13905  {
13907 
13908  setEnumeration<CrossType>(offset, value);
13909  return *this;
13910  }
13911 
13914  {
13916 
13917  setOrdinary(offset, NullUint8EnumEncoding());
13918  return *this;
13919  }
13920 
13921  /// Indicates if one side or the other of a cross order should
13922  /// be prioritized. Null value indicates report is not
13923  /// related to cross.
13925  bool
13927  CrossPrioritization::Enum& value) const
13929  {
13931 
13932  return enumeration<CrossPrioritization>(value, offset, NullUInt8());
13933  }
13934 
13935  /// Indicates if one side or the other of a cross order should
13936  /// be prioritized. Null value indicates report is not
13937  /// related to cross.
13938  ThisType&
13942  {
13944 
13945  setEnumeration<CrossPrioritization>(offset, value);
13946  return *this;
13947  }
13948 
13951  {
13953 
13954  setOrdinary(offset, NullUInt8());
13955  return *this;
13956  }
13957 
13958  /// Client-assigned identification of a strategy.
13960  bool
13962  StrategyIDOptional& value) const
13964  {
13966 
13967  return ordinary(value, offset, NullStrategyIDOptional());
13968  }
13969 
13970  /// Client-assigned identification of a strategy.
13973  {
13975 
13976  setOrdinary(offset, value);
13977  return *this;
13978  }
13979 
13982  {
13984 
13985  setOrdinary(offset, NullStrategyIDOptional());
13986  return *this;
13987  }
13988 
13989  /// Unique ID for all matches that occur as a result of a
13990  /// implied event.
13992  bool impliedEventId(ImpliedEventID& value) const
13994  {
13997 
13998  return ordinary(value, offset, NullImpliedEventID(), since);
13999  }
14000 
14001  /// Unique ID for all matches that occur as a result of a
14002  /// implied event.
14004  {
14007 
14008  setOrdinary(offset, value, since);
14009  return *this;
14010  }
14011 
14013  {
14016 
14017  setOrdinary(offset, NullImpliedEventID(), since);
14018  return *this;
14019  }
14020 
14021  /// Account used for associating risk limits (when defined).
14025  {
14028 
14029  return ordinary(value, offset, NullAccountOptional(), since);
14030  }
14031 
14032  /// Account used for associating risk limits (when defined).
14034  {
14037 
14038  setOrdinary(offset, value, since);
14039  return *this;
14040  }
14041 
14043  {
14046 
14047  setOrdinary(offset, NullAccountOptional(), since);
14048  return *this;
14049  }
14050 
14051  /// Identifies the trading desk.
14053  StrRef deskId() const
14055  {
14056  return getVariableLengthField(deskIDAccess(), *this);
14057  }
14058 
14059  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
14061  StrRef memo() const
14063  {
14064  return getVariableLengthField(memoAccess(), *this);
14065  }
14066 
14067  /// Identifies the trading desk.
14068  ThisType& setDeskId(StrRef value)
14069  {
14070  setVariableLengthField(
14071  deskIDAccess(),
14072  value,
14073  *this);
14074 
14075  return *this;
14076  }
14077 
14078  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
14079  ThisType& setMemo(StrRef value)
14080  {
14081  setVariableLengthField(
14082  memoAccess(),
14083  value,
14084  *this);
14085 
14086  return *this;
14087  }
14088 
14089  /// Minimal size of message body in bytes.
14094  {
14095  return
14096  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
14097  (version >= 5)
14098  ? 174
14099  : (version >= 4)
14100  ? 170
14101  : (version >= 3)
14102  ? 164
14103  : 159;
14104  }
14105 
14106  /// Size of message body in bytes.
14109  static
14110  BlockLength
14114  {
14115  return
14116  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
14117  minimalBlockLength(version);
14118  }
14119 
14120  /// Minimal variable fields size (when variable-length fields are empty).
14124  static
14125  MessageSize
14128  {
14129  return
14130  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
14131  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
14132  }
14133 
14134  /// Maximal message size.
14138  static UInt64 getMaxMessageSize(UInt8)
14140  {
14141  return
14143  }
14144 
14145  /// Reset all variable-length fields if any.
14148  {
14149  setDeskIdToNull();
14150  setMemoToNull();
14151  return *this;
14152  }
14153 
14154  /// Reset all variable-length and optional fields if any.
14155  ThisType& reset()
14157  {
14158  setClOrdIdToNull();
14159  setAccountToNull();
14160  setOrderCategoryToNull();
14161  setMultiLegReportingTypeToNull();
14162  setTotNoRelatedSymToNull();
14163  setSecondaryExecIdToNull();
14164  setExecRefIdToNull();
14165  setCrossIdToNull();
14166  setCrossedIndicatorToNull();
14167  setTradingSessionIdToNull();
14168  setTradingSessionSubIdToNull();
14169  setSecurityTradingStatusToNull();
14170  setCrossTypeToNull();
14171  setCrossPrioritizationToNull();
14172  setStrategyIdToNull();
14173 
14174  if (version() >= 4)
14175  {
14176  setImpliedEventIdToNull();
14177  }
14178 
14179  if (version() >= 5)
14180  {
14181  setTradingSubAccountToNull();
14182  }
14183 
14184  resetVariableFields();
14185  return *this;
14186  }
14187 
14188  /// \return class name.
14192  static const Char* className()
14193  {
14194  return "ExecutionReportTrade203";
14195  }
14196 
14197  /// FIX message type.
14201  static StrRef fixType()
14203  {
14204  return constructStrRef(
14205  "ExecutionReportTrade203");
14206  }
14207 
14208  /// \return a human-readable presentation.
14210  std::string toString() const;
14211 
14212  /// \return the end of the message.
14214  const void* tail() const
14216  {
14217  return
14218  toOpaquePtr(
14219  (memo().end()));
14220  }
14221 
14222  /// \return the size occupied by the message.
14226  {
14227  return
14228  SbeMessage::calculateBinarySize(tail());
14229  }
14230 
14231 private:
14232  void checkLength(
14233  EncodedLength length, SchemaVersion version) const
14234  {
14235  const EncodedLength minimalRequiredLength =
14236  minimalBlockLength(version) +
14237  MessageHeader::Size +
14238  getMinimalVariableFieldsSize(version);
14239 
14240  checkBinaryLength(
14241  *this, length, minimalRequiredLength);
14242  }
14243 
14244  /// Checks variable fields consistency.
14245  void checkVarLenFields() const
14246  {
14247  variableLengthFields().
14248  checkTail<DeskIDEncoding>().
14249  checkTail<MemoEncoding>();
14250  }
14251 
14252  void checkCompatibility() const
14253  {
14254  assert(TemplateId == templateId());
14255 
14256  checkSchema<Schema>(schemaId(), version());
14257  checkLength(bufferSize(), version());
14258  checkVarLenFields();
14259  }
14260 
14261  /// Access helper.
14262  struct deskIDAccess
14263  {
14265  operator()(
14266  const ExecutionReportTrade203& obj) const
14268  {
14269  return obj.
14270  variableLengthFields().
14271  head<DeskIDEncoding>();
14272  }
14273  };
14274 
14275  /// Access helper.
14276  struct memoAccess
14277  {
14278  MemoEncoding&
14279  operator()(
14280  const ExecutionReportTrade203& obj) const
14282  {
14283  return obj.
14284  variableLengthFields().
14285  tail<DeskIDEncoding>().
14286  head<MemoEncoding>();
14287  }
14288  };
14289 
14290  /// Reset the field.
14291  /// All the following data will be invalidated.
14292  ThisType& setDeskIdToNull()
14294  {
14295  setVariableLengthFieldToNull(deskIDAccess(), *this);
14296 
14297  return *this;
14298  }
14299 
14300  /// Reset the field.
14301  /// All the following data will be invalidated.
14302  ThisType& setMemoToNull()
14304  {
14305  setVariableLengthFieldToNull(memoAccess(), *this);
14306 
14307  return *this;
14308  }
14309 };
14310 
14311 /// Execution Report - Reject message notifies the reason a client request was not accepted by Matching Engine.
14314 : SbeMessage
14315 {
14316  /// Used template schema.
14318 
14319  /// This type alias.
14321 
14322  /// Message template ID from SBE schema.
14323  enum { TemplateId = 204 };
14324 
14325  /// Initializes a blank instance.
14327 
14328  /// Initializes an instance over the given memory block.
14330  void* data,
14331  EncodedLength length,
14332  SchemaVersion version = Schema::Version)
14333  : SbeMessage(data, length, version)
14334  {
14335  checkVersion<Schema>(version);
14336  checkLength(length, version);
14337  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
14338  reset();
14339  }
14340 
14341  /// Initializes an instance over the given memory block
14342  /// With no variable-length fields initialization
14343  /// It is assumed that the user does such an initialization manually.
14345  void* data,
14346  EncodedLength length,
14347  NoFieldsInit,
14348  SchemaVersion version = Schema::Version)
14349  : SbeMessage(data, length, version)
14350  {
14351  checkVersion<Schema>(version);
14352  checkLength(length, version);
14353  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
14354  resetVariableFields();
14355  }
14356 
14357  /// Creates an instance over the given memory block.
14359  void* data,
14360  EncodedLength length,
14361  NoInit)
14362  : SbeMessage(data, length)
14363  {
14364  checkCompatibility();
14365  }
14366 
14367  /// Creates an instance over the given SBE message.
14368  explicit
14370  const SbeMessage& message)
14371  : SbeMessage(message)
14372  {
14373  assert(message.valid());
14374 
14375  checkCompatibility();
14376  }
14377 
14378  /// Creates an instance over the given memory block.
14379  /// Performs no checks.
14381  void* data,
14382  EncodedLength length,
14383  NoInit,
14384  NoCheck)
14386  : SbeMessage(data, length, NoCheck())
14387  {
14388  assert(schemaId() == Schema::Id);
14389  assert(version() >= Schema::MinimalVersion);
14390  assert(TemplateId == templateId());
14391  }
14392 
14393  /// MessageType.ExecutionReport_Reject.
14398  {
14399  return MessageType::ExecutionReportReject;
14400  }
14401 
14402  /// MessageType.ExecutionReport_Reject.
14403 
14404  /// Common header to all outbound business messages.
14406  const OutboundBusinessHeader&
14409  {
14411 
14412  return accessOrdinary<OutboundBusinessHeader>(offset);
14413  }
14414 
14415  /// Common header to all outbound business messages.
14418  {
14420  return accessOrdinary<OutboundBusinessHeader>(offset);
14421  }
14422 
14423  /// Side of order.
14427  {
14429 
14430  return enumeration<Side>(offset);
14431  }
14432 
14433  /// Side of order.
14434  ThisType& setSide(Side::Enum value)
14436  {
14438 
14439  setEnumeration<Side>(offset, value);
14440  return *this;
14441  }
14442 
14443  /// Identifies current status of order.
14448  {
14449  return OrdStatus::Rejected;
14450  }
14451 
14452  /// Identifies current status of order.
14453 
14454  /// Identifies the type of request that this Cancel Reject is
14455  /// in response to.
14459  {
14461 
14462  return enumeration<CxlRejResponseTo>(offset);
14463  }
14464 
14465  /// Identifies the type of request that this Cancel Reject is
14466  /// in response to.
14467  ThisType&
14469  CxlRejResponseTo::Enum value)
14471  {
14473 
14474  setEnumeration<CxlRejResponseTo>(offset, value);
14475  return *this;
14476  }
14477 
14478  /// Unique identifier of the order as assigned by the market
14479  /// participant.
14483  {
14485 
14486  return ordinary<ClOrdID>(offset);
14487  }
14488 
14489  /// Unique identifier of the order as assigned by the market
14490  /// participant.
14491  ThisType& setClOrdId(ClOrdID value)
14493  {
14495 
14496  setOrdinary(offset, value);
14497  return *this;
14498  }
14499 
14500  /// Exchange-generated order identifier that changes for each
14501  /// order modification event, or quantity replenishment in
14502  /// disclosed orders.
14506  {
14508 
14509  return ordinary(value, offset, NullOrderIDOptional());
14510  }
14511 
14512  /// Exchange-generated order identifier that changes for each
14513  /// order modification event, or quantity replenishment in
14514  /// disclosed orders.
14517  {
14519 
14520  setOrdinary(offset, value);
14521  return *this;
14522  }
14523 
14526  {
14528 
14529  setOrdinary(offset, NullOrderIDOptional());
14530  return *this;
14531  }
14532 
14533  /// Security identification as defined by exchange.
14537  {
14539 
14540  return ordinary<SecurityID>(offset);
14541  }
14542 
14543  /// Security identification as defined by exchange.
14544  ThisType& setSecurityId(SecurityID value)
14546  {
14548 
14549  setOrdinary(offset, value);
14550  return *this;
14551  }
14552 
14553  /// Identifies the class of the SecurityID (Exchange Symbol).
14558  {
14559  return SecurityIDSource::ExchangeSymbol;
14560  }
14561 
14562  /// Identifies the class of the SecurityID (Exchange Symbol).
14563 
14564  /// Market to which the symbol belongs.
14570  {
14571  return constructStrRef("BVMF");
14572  }
14573 
14574  /// Code to identify reason for order rejection. Please refer
14575  /// to the error codes document for domain information.
14579  {
14581 
14582  return ordinary<RejReason>(offset);
14583  }
14584 
14585  /// Code to identify reason for order rejection. Please refer
14586  /// to the error codes document for domain information.
14587  ThisType& setOrdRejReason(RejReason value)
14589  {
14591 
14592  setOrdinary(offset, value);
14593  return *this;
14594  }
14595 
14596  /// Time of execution/order creation.
14600  {
14602 
14603  return ordinary<UTCTimestampNanos>(offset);
14604  }
14605 
14606  /// Time of execution/order creation.
14609  {
14611 
14612  setOrdinary(offset, value);
14613  return *this;
14614  }
14615 
14616  /// Unique identifier of execution message as assigned by the
14617  /// exchange – unique per instrument.
14619  ExecID execId() const
14621  {
14623 
14624  return ordinary<ExecID>(offset);
14625  }
14626 
14627  /// Unique identifier of execution message as assigned by the
14628  /// exchange – unique per instrument.
14629  ThisType& setExecId(ExecID value)
14631  {
14633 
14634  setOrdinary(offset, value);
14635  return *this;
14636  }
14637 
14638  /// Unique identifier for order as assigned by the exchange.
14640  bool orderId(OrderIDOptional& value) const
14642  {
14644 
14645  return ordinary(value, offset, NullOrderIDOptional());
14646  }
14647 
14648  /// Unique identifier for order as assigned by the exchange.
14649  ThisType& setOrderId(OrderIDOptional value)
14651  {
14653 
14654  setOrdinary(offset, value);
14655  return *this;
14656  }
14657 
14658  ThisType& setOrderIdToNull()
14660  {
14662 
14663  setOrdinary(offset, NullOrderIDOptional());
14664  return *this;
14665  }
14666 
14667  /// Value of origClOrdID field informed from the related
14668  /// request message.
14670  bool origClOrdId(ClOrdIDOptional& value) const
14672  {
14674 
14675  return ordinary(value, offset, NullClOrdIDOptional());
14676  }
14677 
14678  /// Value of origClOrdID field informed from the related
14679  /// request message.
14682  {
14684 
14685  setOrdinary(offset, value);
14686  return *this;
14687  }
14688 
14691  {
14693 
14694  setOrdinary(offset, NullClOrdIDOptional());
14695  return *this;
14696  }
14697 
14698  /// Account mnemonic of the order.
14700  bool account(AccountOptional& value) const
14702  {
14704 
14705  return ordinary(value, offset, NullAccountOptional());
14706  }
14707 
14708  /// Account mnemonic of the order.
14709  ThisType& setAccount(AccountOptional value)
14711  {
14713 
14714  setOrdinary(offset, value);
14715  return *this;
14716  }
14717 
14718  ThisType& setAccountToNull()
14720  {
14722 
14723  setOrdinary(offset, NullAccountOptional());
14724  return *this;
14725  }
14726 
14727  /// Order type.
14731  {
14733 
14734  return enumeration<OrdType>(offset);
14735  }
14736 
14737  /// Order type.
14738  ThisType& setOrdType(OrdType::Enum value)
14740  {
14742 
14743  setEnumeration<OrdType>(offset, value);
14744  return *this;
14745  }
14746 
14747  /// Specifies how long the order remains in effect.
14751  {
14753 
14754  return enumeration<TimeInForce>(offset);
14755  }
14756 
14757  /// Specifies how long the order remains in effect.
14760  {
14762 
14763  setEnumeration<TimeInForce>(offset, value);
14764  return *this;
14765  }
14766 
14767  /// Date of order expiration (last day the order can trade),
14768  /// always expressed in terms of the local market date.
14770  bool expireDate(Timestamp& value) const
14772  {
14773  typedef LocalMktDateOptional FieldValue;
14774 
14776 
14777  FieldValue fieldValue;
14778 
14779  if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
14780  {
14781  value = localMktDateToTimestamp(fieldValue);
14782  return true;
14783  }
14784  return false;
14785  }
14786 
14787  /// Date of order expiration (last day the order can trade),
14788  /// always expressed in terms of the local market date.
14789  ThisType& setExpireDate(Timestamp value)
14791  {
14793 
14794  setOrdinary(offset, timestampToLocalMktDate(value));
14795  return *this;
14796  }
14797 
14800  {
14802 
14803  setOrdinary(offset, NullLocalMktDateOptional());
14804  return *this;
14805  }
14806 
14807  /// Quantity ordered. Not presented if the order to be
14808  /// cancelled is not found.
14810  bool orderQty(QuantityOptional& value) const
14812  {
14814 
14815  return ordinary(value, offset, NullQuantityOptional());
14816  }
14817 
14818  /// Quantity ordered. Not presented if the order to be
14819  /// cancelled is not found.
14822  {
14824 
14825  setOrdinary(offset, value);
14826  return *this;
14827  }
14828 
14829  ThisType& setOrderQtyToNull()
14831  {
14833 
14834  setOrdinary(offset, NullQuantityOptional());
14835  return *this;
14836  }
14837 
14838  /// Price per share or contract. Conditionally required if the
14839  /// order type requires a price (not market orders and RLP).
14841  bool price(PriceOptional& value) const
14843  {
14845 
14846  return decimal(value, offset, NullPriceOptional());
14847  }
14848 
14849  /// Price per share or contract. Conditionally required if the
14850  /// order type requires a price (not market orders and RLP).
14851  ThisType& setPrice(PriceOptional value)
14853  {
14855 
14856  setOrdinary(offset, value);
14857  return *this;
14858  }
14859 
14860  ThisType& setPriceToNull()
14862  {
14864 
14865  setOrdinary(offset, NullPriceOptional());
14866  return *this;
14867  }
14868 
14869  /// The stop price of a stop limit order (Conditionally
14870  /// required if OrdType = 4).
14872  bool stopPx(PriceOptional& value) const
14874  {
14876 
14877  return decimal(value, offset, NullPriceOptional());
14878  }
14879 
14880  /// The stop price of a stop limit order (Conditionally
14881  /// required if OrdType = 4).
14882  ThisType& setStopPx(PriceOptional value)
14884  {
14886 
14887  setOrdinary(offset, value);
14888  return *this;
14889  }
14890 
14891  ThisType& setStopPxToNull()
14893  {
14895 
14896  setOrdinary(offset, NullPriceOptional());
14897  return *this;
14898  }
14899 
14900  /// Minimum quantity of an order to be executed.
14902  bool minQty(QuantityOptional& value) const
14904  {
14906 
14907  return ordinary(value, offset, NullQuantityOptional());
14908  }
14909 
14910  /// Minimum quantity of an order to be executed.
14911  ThisType& setMinQty(QuantityOptional value)
14913  {
14915 
14916  setOrdinary(offset, value);
14917  return *this;
14918  }
14919 
14920  ThisType& setMinQtyToNull()
14922  {
14924 
14925  setOrdinary(offset, NullQuantityOptional());
14926  return *this;
14927  }
14928 
14929  /// Maximum number of shares or contracts within an order to
14930  /// be shown on the match engine at any given time.
14932  bool maxFloor(QuantityOptional& value) const
14934  {
14936 
14937  return ordinary(value, offset, NullQuantityOptional());
14938  }
14939 
14940  /// Maximum number of shares or contracts within an order to
14941  /// be shown on the match engine at any given time.
14944  {
14946 
14947  setOrdinary(offset, value);
14948  return *this;
14949  }
14950 
14951  ThisType& setMaxFloorToNull()
14953  {
14955 
14956  setOrdinary(offset, NullQuantityOptional());
14957  return *this;
14958  }
14959 
14960  /// ID of electronically submitted cross order by the
14961  /// institution (if in response to a cross order).
14963  bool crossId(CrossIDOptional& value) const
14965  {
14967 
14968  return ordinary(value, offset, NullCrossIDOptional());
14969  }
14970 
14971  /// ID of electronically submitted cross order by the
14972  /// institution (if in response to a cross order).
14973  ThisType& setCrossId(CrossIDOptional value)
14975  {
14977 
14978  setOrdinary(offset, value);
14979  return *this;
14980  }
14981 
14982  ThisType& setCrossIdToNull()
14984  {
14986 
14987  setOrdinary(offset, NullCrossIDOptional());
14988  return *this;
14989  }
14990 
14991  /// Indicates cross order purpose.
14993  bool
14995  CrossedIndicator::Enum& value) const
14997  {
14999 
15000  return enumeration<CrossedIndicator>(value, offset, NullUint16EnumEncoding());
15001  }
15002 
15003  /// Indicates cross order purpose.
15004  ThisType&
15006  CrossedIndicator::Enum value)
15008  {
15010 
15011  setEnumeration<CrossedIndicator>(offset, value);
15012  return *this;
15013  }
15014 
15017  {
15019 
15020  setOrdinary(offset, NullUint16EnumEncoding());
15021  return *this;
15022  }
15023 
15024  /// Time of receipt of related inbound message in the gateway.
15026  bool
15028  UTCTimestampNanosOptional& value) const
15030  {
15032 
15033  return ordinary(value, offset, NullUTCTimestampNanosOptional());
15034  }
15035 
15036  /// Time of receipt of related inbound message in the gateway.
15037  ThisType&
15041  {
15043 
15044  setOrdinary(offset, value);
15045  return *this;
15046  }
15047 
15050  {
15052 
15053  setOrdinary(offset, NullUTCTimestampNanosOptional());
15054  return *this;
15055  }
15056 
15057  /// Identifies the order tag identification.
15059  bool ordTagId(OrdTagID& value) const
15061  {
15063 
15064  return ordinary(value, offset, NullOrdTagID());
15065  }
15066 
15067  /// Identifies the order tag identification.
15068  ThisType& setOrdTagId(OrdTagID value)
15070  {
15072 
15073  setOrdinary(offset, value);
15074  return *this;
15075  }
15076 
15077  ThisType& setOrdTagIdToNull()
15079  {
15081 
15082  setOrdinary(offset, NullOrdTagID());
15083  return *this;
15084  }
15085 
15086  /// Unique identifier of investor for self trade
15087  /// prevention/mass cancel on behalf purposes.
15089  bool investorId(InvestorID& value) const
15091  {
15093 
15094  return ordinary(value, offset, NullInvestorID());
15095  }
15096 
15097  /// Unique identifier of investor for self trade
15098  /// prevention/mass cancel on behalf purposes.
15099  ThisType& setInvestorId(InvestorID value)
15101  {
15103 
15104  setOrdinary(offset, value);
15105  return *this;
15106  }
15107 
15110  {
15112 
15113  setOrdinary(offset, NullInvestorID());
15114  return *this;
15115  }
15116 
15117  /// Client-assigned identification of a strategy.
15119  bool
15121  StrategyIDOptional& value) const
15123  {
15125 
15126  return ordinary(value, offset, NullStrategyIDOptional());
15127  }
15128 
15129  /// Client-assigned identification of a strategy.
15132  {
15134 
15135  setOrdinary(offset, value);
15136  return *this;
15137  }
15138 
15141  {
15143 
15144  setOrdinary(offset, NullStrategyIDOptional());
15145  return *this;
15146  }
15147 
15148  /// Account used for associating risk limits (when defined).
15152  {
15155 
15156  return ordinary(value, offset, NullAccountOptional(), since);
15157  }
15158 
15159  /// Account used for associating risk limits (when defined).
15161  {
15164 
15165  setOrdinary(offset, value, since);
15166  return *this;
15167  }
15168 
15170  {
15173 
15174  setOrdinary(offset, NullAccountOptional(), since);
15175  return *this;
15176  }
15177 
15178  /// Identifies the trading desk.
15180  StrRef deskId() const
15182  {
15183  return getVariableLengthField(deskIDAccess(), *this);
15184  }
15185 
15186  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
15188  StrRef memo() const
15190  {
15191  return getVariableLengthField(memoAccess(), *this);
15192  }
15193 
15194  /// Free ASCII format text string.
15196  StrRef text() const
15198  {
15199  return getVariableLengthField(textAccess(), *this);
15200  }
15201 
15202  /// Identifies the trading desk.
15203  ThisType& setDeskId(StrRef value)
15204  {
15205  setVariableLengthField(
15206  deskIDAccess(),
15207  value,
15208  *this);
15209 
15210  return *this;
15211  }
15212 
15213  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
15214  ThisType& setMemo(StrRef value)
15215  {
15216  setVariableLengthField(
15217  memoAccess(),
15218  value,
15219  *this);
15220 
15221  return *this;
15222  }
15223 
15224  /// Free ASCII format text string.
15225  ThisType& setText(StrRef value)
15226  {
15227  setVariableLengthField(
15228  textAccess(),
15229  value,
15230  *this);
15231 
15232  return *this;
15233  }
15234 
15235  /// Minimal size of message body in bytes.
15240  {
15241  return
15242  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
15243  (version >= 5)
15244  ? 166
15245  : (version >= 3)
15246  ? 162
15247  : 146;
15248  }
15249 
15250  /// Size of message body in bytes.
15253  static
15254  BlockLength
15258  {
15259  return
15260  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
15261  minimalBlockLength(version);
15262  }
15263 
15264  /// Minimal variable fields size (when variable-length fields are empty).
15268  static
15269  MessageSize
15272  {
15273  return
15274  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
15275  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size) + static_cast<MessageSize>(TextEncoding::Size);
15276  }
15277 
15278  /// Maximal message size.
15282  static UInt64 getMaxMessageSize(UInt8)
15284  {
15285  return
15287  }
15288 
15289  /// Reset all variable-length fields if any.
15292  {
15293  setDeskIdToNull();
15294  setMemoToNull();
15295  setTextToNull();
15296  return *this;
15297  }
15298 
15299  /// Reset all variable-length and optional fields if any.
15300  ThisType& reset()
15302  {
15303  setSecondaryOrderIdToNull();
15304  setOrderIdToNull();
15305  setOrigClOrdIdToNull();
15306  setAccountToNull();
15307  setExpireDateToNull();
15308  setOrderQtyToNull();
15309  setPriceToNull();
15310  setStopPxToNull();
15311  setMinQtyToNull();
15312  setMaxFloorToNull();
15313  setCrossIdToNull();
15314  setCrossedIndicatorToNull();
15315  setReceivedTimeToNull();
15316  setOrdTagIdToNull();
15317  setInvestorIdToNull();
15318  setStrategyIdToNull();
15319 
15320  if (version() >= 5)
15321  {
15322  setTradingSubAccountToNull();
15323  }
15324 
15325  resetVariableFields();
15326  return *this;
15327  }
15328 
15329  /// \return class name.
15333  static const Char* className()
15334  {
15335  return "ExecutionReportReject204";
15336  }
15337 
15338  /// FIX message type.
15342  static StrRef fixType()
15344  {
15345  return constructStrRef(
15346  "ExecutionReportReject204");
15347  }
15348 
15349  /// \return a human-readable presentation.
15351  std::string toString() const;
15352 
15353  /// \return the end of the message.
15355  const void* tail() const
15357  {
15358  return
15359  toOpaquePtr(
15360  (text().end()));
15361  }
15362 
15363  /// \return the size occupied by the message.
15367  {
15368  return
15369  SbeMessage::calculateBinarySize(tail());
15370  }
15371 
15372 private:
15373  void checkLength(
15374  EncodedLength length, SchemaVersion version) const
15375  {
15376  const EncodedLength minimalRequiredLength =
15377  minimalBlockLength(version) +
15378  MessageHeader::Size +
15379  getMinimalVariableFieldsSize(version);
15380 
15381  checkBinaryLength(
15382  *this, length, minimalRequiredLength);
15383  }
15384 
15385  /// Checks variable fields consistency.
15386  void checkVarLenFields() const
15387  {
15388  variableLengthFields().
15389  checkTail<DeskIDEncoding>().
15390  checkTail<MemoEncoding>().
15391  checkTail<TextEncoding>();
15392  }
15393 
15394  void checkCompatibility() const
15395  {
15396  assert(TemplateId == templateId());
15397 
15398  checkSchema<Schema>(schemaId(), version());
15399  checkLength(bufferSize(), version());
15400  checkVarLenFields();
15401  }
15402 
15403  /// Access helper.
15404  struct deskIDAccess
15405  {
15407  operator()(
15408  const ExecutionReportReject204& obj) const
15410  {
15411  return obj.
15412  variableLengthFields().
15413  head<DeskIDEncoding>();
15414  }
15415  };
15416 
15417  /// Access helper.
15418  struct memoAccess
15419  {
15420  MemoEncoding&
15421  operator()(
15422  const ExecutionReportReject204& obj) const
15424  {
15425  return obj.
15426  variableLengthFields().
15427  tail<DeskIDEncoding>().
15428  head<MemoEncoding>();
15429  }
15430  };
15431 
15432  /// Access helper.
15433  struct textAccess
15434  {
15435  TextEncoding&
15436  operator()(
15437  const ExecutionReportReject204& obj) const
15439  {
15440  return obj.
15441  variableLengthFields().
15442  tail<DeskIDEncoding>().
15443  tail<MemoEncoding>().
15444  head<TextEncoding>();
15445  }
15446  };
15447 
15448  /// Reset the field.
15449  /// All the following data will be invalidated.
15450  ThisType& setDeskIdToNull()
15452  {
15453  setVariableLengthFieldToNull(deskIDAccess(), *this);
15454 
15455  return *this;
15456  }
15457 
15458  /// Reset the field.
15459  /// All the following data will be invalidated.
15460  ThisType& setMemoToNull()
15462  {
15463  setVariableLengthFieldToNull(memoAccess(), *this);
15464 
15465  return *this;
15466  }
15467 
15468  /// Reset the field.
15469  /// All the following data will be invalidated.
15470  ThisType& setTextToNull()
15472  {
15473  setVariableLengthFieldToNull(textAccess(), *this);
15474 
15475  return *this;
15476  }
15477 };
15478 
15479 /// Execution Report – Forward message is sent with order fills were traded and processed on Matching Engine for Forward exclusively (Termo).
15482 : SbeMessage
15483 {
15484  /// Used template schema.
15486 
15487  /// This type alias.
15489 
15490  /// Message template ID from SBE schema.
15491  enum { TemplateId = 205 };
15492 
15493  /// Initializes a blank instance.
15495 
15496  /// Initializes an instance over the given memory block.
15498  void* data,
15499  EncodedLength length,
15500  SchemaVersion version = Schema::Version)
15501  : SbeMessage(data, length, version)
15502  {
15503  checkVersion<Schema>(version);
15504  checkLength(length, version);
15505  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
15506  reset();
15507  }
15508 
15509  /// Initializes an instance over the given memory block
15510  /// With no variable-length fields initialization
15511  /// It is assumed that the user does such an initialization manually.
15513  void* data,
15514  EncodedLength length,
15515  NoFieldsInit,
15516  SchemaVersion version = Schema::Version)
15517  : SbeMessage(data, length, version)
15518  {
15519  checkVersion<Schema>(version);
15520  checkLength(length, version);
15521  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
15522  resetVariableFields();
15523  }
15524 
15525  /// Creates an instance over the given memory block.
15527  void* data,
15528  EncodedLength length,
15529  NoInit)
15530  : SbeMessage(data, length)
15531  {
15532  checkCompatibility();
15533  }
15534 
15535  /// Creates an instance over the given SBE message.
15536  explicit
15538  const SbeMessage& message)
15539  : SbeMessage(message)
15540  {
15541  assert(message.valid());
15542 
15543  checkCompatibility();
15544  }
15545 
15546  /// Creates an instance over the given memory block.
15547  /// Performs no checks.
15549  void* data,
15550  EncodedLength length,
15551  NoInit,
15552  NoCheck)
15554  : SbeMessage(data, length, NoCheck())
15555  {
15556  assert(schemaId() == Schema::Id);
15557  assert(version() >= Schema::MinimalVersion);
15558  assert(TemplateId == templateId());
15559  }
15560 
15561  /// MessageType.ExecutionReport_Forward.
15566  {
15567  return MessageType::ExecutionReportForward;
15568  }
15569 
15570  /// MessageType.ExecutionReport_Forward.
15571 
15572  /// Common header to all outbound business messages.
15574  const OutboundBusinessHeader&
15577  {
15579 
15580  return accessOrdinary<OutboundBusinessHeader>(offset);
15581  }
15582 
15583  /// Common header to all outbound business messages.
15586  {
15588  return accessOrdinary<OutboundBusinessHeader>(offset);
15589  }
15590 
15591  /// Side of order.
15595  {
15597 
15598  return enumeration<Side>(offset);
15599  }
15600 
15601  /// Side of order.
15602  ThisType& setSide(Side::Enum value)
15604  {
15606 
15607  setEnumeration<Side>(offset, value);
15608  return *this;
15609  }
15610 
15611  /// Identifies current status of order.
15615  {
15617 
15618  return enumeration<OrdStatus>(offset);
15619  }
15620 
15621  /// Identifies current status of order.
15624  {
15626 
15627  setEnumeration<OrdStatus>(offset, value);
15628  return *this;
15629  }
15630 
15631  /// Unique identifier of the order as assigned by the market
15632  /// participant.
15634  bool clOrdId(ClOrdIDOptional& value) const
15636  {
15638 
15639  return ordinary(value, offset, NullClOrdIDOptional());
15640  }
15641 
15642  /// Unique identifier of the order as assigned by the market
15643  /// participant.
15644  ThisType& setClOrdId(ClOrdIDOptional value)
15646  {
15648 
15649  setOrdinary(offset, value);
15650  return *this;
15651  }
15652 
15653  ThisType& setClOrdIdToNull()
15655  {
15657 
15658  setOrdinary(offset, NullClOrdIDOptional());
15659  return *this;
15660  }
15661 
15662  /// Exchange-generated order identifier that changes for each
15663  /// order modification event, or quantity replenishment in
15664  /// disclosed orders.
15668  {
15670 
15671  return ordinary<OrderID>(offset);
15672  }
15673 
15674  /// Exchange-generated order identifier that changes for each
15675  /// order modification event, or quantity replenishment in
15676  /// disclosed orders.
15677  ThisType& setSecondaryOrderId(OrderID value)
15679  {
15681 
15682  setOrdinary(offset, value);
15683  return *this;
15684  }
15685 
15686  /// Security identification as defined by exchange.
15690  {
15692 
15693  return ordinary<SecurityID>(offset);
15694  }
15695 
15696  /// Security identification as defined by exchange.
15697  ThisType& setSecurityId(SecurityID value)
15699  {
15701 
15702  setOrdinary(offset, value);
15703  return *this;
15704  }
15705 
15706  /// Identifies the class of the SecurityID (Exchange Symbol).
15711  {
15712  return SecurityIDSource::ExchangeSymbol;
15713  }
15714 
15715  /// Identifies the class of the SecurityID (Exchange Symbol).
15716 
15717  /// Market to which the symbol belongs.
15723  {
15724  return constructStrRef("BVMF");
15725  }
15726 
15727  /// Account mnemonic of the order.
15729  bool account(AccountOptional& value) const
15731  {
15733 
15734  return ordinary(value, offset, NullAccountOptional());
15735  }
15736 
15737  /// Account mnemonic of the order.
15738  ThisType& setAccount(AccountOptional value)
15740  {
15742 
15743  setOrdinary(offset, value);
15744  return *this;
15745  }
15746 
15747  ThisType& setAccountToNull()
15749  {
15751 
15752  setOrdinary(offset, NullAccountOptional());
15753  return *this;
15754  }
15755 
15756  /// Quantity of shares bought/sold on the last fill.
15760  {
15762 
15763  return ordinary<Quantity>(offset);
15764  }
15765 
15766  /// Quantity of shares bought/sold on the last fill.
15767  ThisType& setLastQty(Quantity value)
15769  {
15771 
15772  setOrdinary(offset, value);
15773  return *this;
15774  }
15775 
15776  /// Price of last fill.
15778  Price lastPx() const
15780  {
15782 
15783  return decimal<Price>(offset);
15784  }
15785 
15786  /// Price of last fill.
15787  ThisType& setLastPx(Price value)
15789  {
15791 
15792  setOrdinary(offset, value);
15793  return *this;
15794  }
15795 
15796  /// Unique identifier of execution message as assigned by the
15797  /// exchange – unique per instrument.
15799  ExecID execId() const
15801  {
15803 
15804  return ordinary<ExecID>(offset);
15805  }
15806 
15807  /// Unique identifier of execution message as assigned by the
15808  /// exchange – unique per instrument.
15809  ThisType& setExecId(ExecID value)
15811  {
15813 
15814  setOrdinary(offset, value);
15815  return *this;
15816  }
15817 
15818  /// Time of execution/order creation.
15822  {
15824 
15825  return ordinary<UTCTimestampNanos>(offset);
15826  }
15827 
15828  /// Time of execution/order creation.
15831  {
15833 
15834  setOrdinary(offset, value);
15835  return *this;
15836  }
15837 
15838  /// Amount of shares open for further execution, or
15839  /// unexecuted.
15843  {
15845 
15846  return ordinary<Quantity>(offset);
15847  }
15848 
15849  /// Amount of shares open for further execution, or
15850  /// unexecuted.
15851  ThisType& setLeavesQty(Quantity value)
15853  {
15855 
15856  setOrdinary(offset, value);
15857  return *this;
15858  }
15859 
15860  /// Total number of shares or contracts filled.
15864  {
15866 
15867  return ordinary<Quantity>(offset);
15868  }
15869 
15870  /// Total number of shares or contracts filled.
15871  ThisType& setCumQty(Quantity value)
15873  {
15875 
15876  setOrdinary(offset, value);
15877  return *this;
15878  }
15879 
15880  /// Contains the unique identifier for this trade, per
15881  /// instrument + trading date, as assigned by the exchange.
15885  {
15887 
15888  return ordinary<TradeID>(offset);
15889  }
15890 
15891  /// Contains the unique identifier for this trade, per
15892  /// instrument + trading date, as assigned by the exchange.
15893  ThisType& setTradeId(TradeID value)
15895  {
15897 
15898  setOrdinary(offset, value);
15899  return *this;
15900  }
15901 
15902  /// Identifies the contra broker firm.
15906  {
15908 
15909  return ordinary<Firm>(offset);
15910  }
15911 
15912  /// Identifies the contra broker firm.
15913  ThisType& setContraBroker(Firm value)
15915  {
15917 
15918  setOrdinary(offset, value);
15919  return *this;
15920  }
15921 
15922  /// Unique identifier for order as assigned by the exchange.
15926  {
15928 
15929  return ordinary<OrderID>(offset);
15930  }
15931 
15932  /// Unique identifier for order as assigned by the exchange.
15933  ThisType& setOrderId(OrderID value)
15935  {
15937 
15938  setOrdinary(offset, value);
15939  return *this;
15940  }
15941 
15942  /// Identify whether the order initiator is an aggressor or
15943  /// not in the trade.
15947  {
15949 
15950  return enumeration<Boolean>(offset);
15951  }
15952 
15953  /// Identify whether the order initiator is an aggressor or
15954  /// not in the trade.
15957  {
15959 
15960  setEnumeration<Boolean>(offset, value);
15961  return *this;
15962  }
15963 
15964  /// Indicates who in the contract has control over evoking
15965  /// settlement.
15967  bool settlType(SettlType::Enum& value) const
15969  {
15971 
15972  return enumeration<SettlType>(value, offset, NullChar());
15973  }
15974 
15975  /// Indicates who in the contract has control over evoking
15976  /// settlement.
15979  {
15981 
15982  setEnumeration<SettlType>(offset, value);
15983  return *this;
15984  }
15985 
15988  {
15990 
15991  setOrdinary(offset, NullChar());
15992  return *this;
15993  }
15994 
15995  /// Indicates date of trading day (expressed in local time at
15996  /// place of trade). Sent in number of days since Unix epoch.
16000  {
16002 
16003  return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
16004  }
16005 
16006  /// Indicates date of trading day (expressed in local time at
16007  /// place of trade). Sent in number of days since Unix epoch.
16008  ThisType& setTradeDate(Timestamp value)
16010  {
16012 
16013  setOrdinary(offset, timestampToLocalMktDate(value));
16014  return *this;
16015  }
16016 
16017  /// Deadline for completing the forward deal. For Common,
16018  /// Dollar and Index contracts must be between 16 and 999. And
16019  /// maximum of 90 days for Flexible.
16021  bool
16023  DaysToSettlementOptional& value) const
16025  {
16027 
16028  return ordinary(value, offset, NullDaysToSettlementOptional());
16029  }
16030 
16031  /// Deadline for completing the forward deal. For Common,
16032  /// Dollar and Index contracts must be between 16 and 999. And
16033  /// maximum of 90 days for Flexible.
16034  ThisType&
16038  {
16040 
16041  setOrdinary(offset, value);
16042  return *this;
16043  }
16044 
16047  {
16049 
16050  setOrdinary(offset, NullDaysToSettlementOptional());
16051  return *this;
16052  }
16053 
16054  /// Unique identifier present in all messages associated with
16055  /// a spread transaction. This value allows linking spread
16056  /// summary fill notice, leg fill notices, and leg trade
16057  /// cancellation execution report messages generated from a
16058  /// spread transaction.
16060  bool secondaryExecId(ExecIDOptional& value) const
16062  {
16064 
16065  return ordinary(value, offset, NullExecIDOptional());
16066  }
16067 
16068  /// Unique identifier present in all messages associated with
16069  /// a spread transaction. This value allows linking spread
16070  /// summary fill notice, leg fill notices, and leg trade
16071  /// cancellation execution report messages generated from a
16072  /// spread transaction.
16075  {
16077 
16078  setOrdinary(offset, value);
16079  return *this;
16080  }
16081 
16084  {
16086 
16087  setOrdinary(offset, NullExecIDOptional());
16088  return *this;
16089  }
16090 
16091  /// Optionally sent when reporting a trade bust. Contains the
16092  /// identifier of the busted trade.
16094  bool execRefId(ExecIDOptional& value) const
16096  {
16098 
16099  return ordinary(value, offset, NullExecIDOptional());
16100  }
16101 
16102  /// Optionally sent when reporting a trade bust. Contains the
16103  /// identifier of the busted trade.
16104  ThisType& setExecRefId(ExecIDOptional value)
16106  {
16108 
16109  setOrdinary(offset, value);
16110  return *this;
16111  }
16112 
16115  {
16117 
16118  setOrdinary(offset, NullExecIDOptional());
16119  return *this;
16120  }
16121 
16122  /// Describes the interest to be paid by the forward buyer and
16123  /// received by the forward seller, in proportion to the
16124  /// agreed days to settlement. Expressed in decimal form. For
16125  /// example, 1% is expressed and sent as 0.01. One basis point
16126  /// is represented as 0.0001.
16128  bool
16130  Percentage8Optional& value) const
16132  {
16134 
16135  return decimal(value, offset, NullPercentage8Optional());
16136  }
16137 
16138  /// Describes the interest to be paid by the forward buyer and
16139  /// received by the forward seller, in proportion to the
16140  /// agreed days to settlement. Expressed in decimal form. For
16141  /// example, 1% is expressed and sent as 0.01. One basis point
16142  /// is represented as 0.0001.
16143  ThisType&
16145  Percentage8Optional value)
16147  {
16149 
16150  setOrdinary(offset, value);
16151  return *this;
16152  }
16153 
16156  {
16158 
16159  setOrdinary(offset, NullPercentage8Optional());
16160  return *this;
16161  }
16162 
16163  /// Quantity ordered.
16167  {
16169 
16170  return ordinary<Quantity>(offset);
16171  }
16172 
16173  /// Quantity ordered.
16174  ThisType& setOrderQty(Quantity value)
16176  {
16178 
16179  setOrdinary(offset, value);
16180  return *this;
16181  }
16182 
16183  /// Identifier for Trading Session.
16185  bool
16187  TradingSessionID::Enum& value) const
16189  {
16191 
16192  return enumeration<TradingSessionID>(value, offset, NullUint8EnumEncoding());
16193  }
16194 
16195  /// Identifier for Trading Session.
16196  ThisType&
16198  TradingSessionID::Enum value)
16200  {
16202 
16203  setEnumeration<TradingSessionID>(offset, value);
16204  return *this;
16205  }
16206 
16209  {
16211 
16212  setOrdinary(offset, NullUint8EnumEncoding());
16213  return *this;
16214  }
16215 
16216  /// Identifier for the instrument group phase.
16218  bool
16220  TradingSessionSubID::Enum& value) const
16222  {
16224 
16225  return enumeration<TradingSessionSubID>(value, offset, NullUint8EnumEncoding());
16226  }
16227 
16228  /// Identifier for the instrument group phase.
16229  ThisType&
16233  {
16235 
16236  setEnumeration<TradingSessionSubID>(offset, value);
16237  return *this;
16238  }
16239 
16242  {
16244 
16245  setOrdinary(offset, NullUint8EnumEncoding());
16246  return *this;
16247  }
16248 
16249  /// Identifier for the instrument status.
16251  bool
16253  SecurityTradingStatus::Enum& value) const
16255  {
16257 
16258  return enumeration<SecurityTradingStatus>(value, offset, NullUint8EnumEncoding());
16259  }
16260 
16261  /// Identifier for the instrument status.
16262  ThisType&
16266  {
16268 
16269  setEnumeration<SecurityTradingStatus>(offset, value);
16270  return *this;
16271  }
16272 
16275  {
16277 
16278  setOrdinary(offset, NullUint8EnumEncoding());
16279  return *this;
16280  }
16281 
16282  /// Account used for associating risk limits (when defined).
16286  {
16289 
16290  return ordinary(value, offset, NullAccountOptional(), since);
16291  }
16292 
16293  /// Account used for associating risk limits (when defined).
16295  {
16298 
16299  setOrdinary(offset, value, since);
16300  return *this;
16301  }
16302 
16304  {
16307 
16308  setOrdinary(offset, NullAccountOptional(), since);
16309  return *this;
16310  }
16311 
16312  /// Identifies the trading desk.
16314  StrRef deskId() const
16316  {
16317  return getVariableLengthField(deskIDAccess(), *this);
16318  }
16319 
16320  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
16322  StrRef memo() const
16324  {
16325  return getVariableLengthField(memoAccess(), *this);
16326  }
16327 
16328  /// Identifies the trading desk.
16329  ThisType& setDeskId(StrRef value)
16330  {
16331  setVariableLengthField(
16332  deskIDAccess(),
16333  value,
16334  *this);
16335 
16336  return *this;
16337  }
16338 
16339  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
16340  ThisType& setMemo(StrRef value)
16341  {
16342  setVariableLengthField(
16343  memoAccess(),
16344  value,
16345  *this);
16346 
16347  return *this;
16348  }
16349 
16350  /// Minimal size of message body in bytes.
16355  {
16356  return
16357  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
16358  (version >= 5)
16359  ? 159
16360  : 155;
16361  }
16362 
16363  /// Size of message body in bytes.
16366  static
16367  BlockLength
16371  {
16372  return
16373  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
16374  minimalBlockLength(version);
16375  }
16376 
16377  /// Minimal variable fields size (when variable-length fields are empty).
16381  static
16382  MessageSize
16385  {
16386  return
16387  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
16388  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
16389  }
16390 
16391  /// Maximal message size.
16395  static UInt64 getMaxMessageSize(UInt8)
16397  {
16398  return
16400  }
16401 
16402  /// Reset all variable-length fields if any.
16405  {
16406  setDeskIdToNull();
16407  setMemoToNull();
16408  return *this;
16409  }
16410 
16411  /// Reset all variable-length and optional fields if any.
16412  ThisType& reset()
16414  {
16415  setClOrdIdToNull();
16416  setAccountToNull();
16417  setSettlTypeToNull();
16418  setDaysToSettlementToNull();
16419  setSecondaryExecIdToNull();
16420  setExecRefIdToNull();
16421  setFixedRateToNull();
16422  setTradingSessionIdToNull();
16423  setTradingSessionSubIdToNull();
16424  setSecurityTradingStatusToNull();
16425 
16426  if (version() >= 5)
16427  {
16428  setTradingSubAccountToNull();
16429  }
16430 
16431  resetVariableFields();
16432  return *this;
16433  }
16434 
16435  /// \return class name.
16439  static const Char* className()
16440  {
16441  return "ExecutionReportForward205";
16442  }
16443 
16444  /// FIX message type.
16448  static StrRef fixType()
16450  {
16451  return constructStrRef(
16452  "ExecutionReportForward205");
16453  }
16454 
16455  /// \return a human-readable presentation.
16457  std::string toString() const;
16458 
16459  /// \return the end of the message.
16461  const void* tail() const
16463  {
16464  return
16465  toOpaquePtr(
16466  (memo().end()));
16467  }
16468 
16469  /// \return the size occupied by the message.
16473  {
16474  return
16475  SbeMessage::calculateBinarySize(tail());
16476  }
16477 
16478 private:
16479  void checkLength(
16480  EncodedLength length, SchemaVersion version) const
16481  {
16482  const EncodedLength minimalRequiredLength =
16483  minimalBlockLength(version) +
16484  MessageHeader::Size +
16485  getMinimalVariableFieldsSize(version);
16486 
16487  checkBinaryLength(
16488  *this, length, minimalRequiredLength);
16489  }
16490 
16491  /// Checks variable fields consistency.
16492  void checkVarLenFields() const
16493  {
16494  variableLengthFields().
16495  checkTail<DeskIDEncoding>().
16496  checkTail<MemoEncoding>();
16497  }
16498 
16499  void checkCompatibility() const
16500  {
16501  assert(TemplateId == templateId());
16502 
16503  checkSchema<Schema>(schemaId(), version());
16504  checkLength(bufferSize(), version());
16505  checkVarLenFields();
16506  }
16507 
16508  /// Access helper.
16509  struct deskIDAccess
16510  {
16512  operator()(
16513  const ExecutionReportForward205& obj) const
16515  {
16516  return obj.
16517  variableLengthFields().
16518  head<DeskIDEncoding>();
16519  }
16520  };
16521 
16522  /// Access helper.
16523  struct memoAccess
16524  {
16525  MemoEncoding&
16526  operator()(
16527  const ExecutionReportForward205& obj) const
16529  {
16530  return obj.
16531  variableLengthFields().
16532  tail<DeskIDEncoding>().
16533  head<MemoEncoding>();
16534  }
16535  };
16536 
16537  /// Reset the field.
16538  /// All the following data will be invalidated.
16539  ThisType& setDeskIdToNull()
16541  {
16542  setVariableLengthFieldToNull(deskIDAccess(), *this);
16543 
16544  return *this;
16545  }
16546 
16547  /// Reset the field.
16548  /// All the following data will be invalidated.
16549  ThisType& setMemoToNull()
16551  {
16552  setVariableLengthFieldToNull(memoAccess(), *this);
16553 
16554  return *this;
16555  }
16556 };
16557 
16558 /// BusinessMessageReject message can reject an application-level message which fulfills session level rules but fails the business rules.
16561 : SbeMessage
16562 {
16563  /// Used template schema.
16565 
16566  /// This type alias.
16568 
16569  /// Message template ID from SBE schema.
16570  enum { TemplateId = 206 };
16571 
16572  /// Initializes a blank instance.
16574 
16575  /// Initializes an instance over the given memory block.
16577  void* data,
16578  EncodedLength length,
16579  SchemaVersion version = Schema::Version)
16580  : SbeMessage(data, length, version)
16581  {
16582  checkVersion<Schema>(version);
16583  checkLength(length, version);
16584  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
16585  reset();
16586  }
16587 
16588  /// Initializes an instance over the given memory block
16589  /// With no variable-length fields initialization
16590  /// It is assumed that the user does such an initialization manually.
16592  void* data,
16593  EncodedLength length,
16594  NoFieldsInit,
16595  SchemaVersion version = Schema::Version)
16596  : SbeMessage(data, length, version)
16597  {
16598  checkVersion<Schema>(version);
16599  checkLength(length, version);
16600  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
16601  resetVariableFields();
16602  }
16603 
16604  /// Creates an instance over the given memory block.
16606  void* data,
16607  EncodedLength length,
16608  NoInit)
16609  : SbeMessage(data, length)
16610  {
16611  checkCompatibility();
16612  }
16613 
16614  /// Creates an instance over the given SBE message.
16615  explicit
16617  const SbeMessage& message)
16618  : SbeMessage(message)
16619  {
16620  assert(message.valid());
16621 
16622  checkCompatibility();
16623  }
16624 
16625  /// Creates an instance over the given memory block.
16626  /// Performs no checks.
16628  void* data,
16629  EncodedLength length,
16630  NoInit,
16631  NoCheck)
16633  : SbeMessage(data, length, NoCheck())
16634  {
16635  assert(schemaId() == Schema::Id);
16636  assert(version() >= Schema::MinimalVersion);
16637  assert(TemplateId == templateId());
16638  }
16639 
16640  /// Message type = BusinessMessageReject.
16645  {
16646  return MessageType::BusinessMessageReject;
16647  }
16648 
16649  /// Message type = BusinessMessageReject.
16650 
16651  /// Common header to all outbound business messages.
16653  const OutboundBusinessHeader&
16656  {
16658 
16659  return accessOrdinary<OutboundBusinessHeader>(offset);
16660  }
16661 
16662  /// Common header to all outbound business messages.
16665  {
16667  return accessOrdinary<OutboundBusinessHeader>(offset);
16668  }
16669 
16670  /// MsgType of the FIX message being referenced.
16674  {
16676 
16677  return enumeration<MessageType>(offset);
16678  }
16679 
16680  /// MsgType of the FIX message being referenced.
16683  {
16685 
16686  setEnumeration<MessageType>(offset, value);
16687  return *this;
16688  }
16689 
16690  /// Message sequence number of rejected message.
16694  {
16696 
16697  return ordinary<SeqNum>(offset);
16698  }
16699 
16700  /// Message sequence number of rejected message.
16701  ThisType& setRefSeqNum(SeqNum value)
16703  {
16705 
16706  setOrdinary(offset, value);
16707  return *this;
16708  }
16709 
16710  /// The value of the business-level “ID” field on the message
16711  /// being referenced. Required unless the corresponding ID
16712  /// field was not specified.
16714  bool
16716  BusinessRejectRefID& value) const
16718  {
16720 
16721  return ordinary(value, offset, NullBusinessRejectRefID());
16722  }
16723 
16724  /// The value of the business-level “ID” field on the message
16725  /// being referenced. Required unless the corresponding ID
16726  /// field was not specified.
16727  ThisType&
16729  BusinessRejectRefID value)
16731  {
16733 
16734  setOrdinary(offset, value);
16735  return *this;
16736  }
16737 
16740  {
16742 
16743  setOrdinary(offset, NullBusinessRejectRefID());
16744  return *this;
16745  }
16746 
16747  /// Code to identify the reason of the rejection.
16751  {
16753 
16754  return ordinary<RejReason>(offset);
16755  }
16756 
16757  /// Code to identify the reason of the rejection.
16760  {
16762 
16763  setOrdinary(offset, value);
16764  return *this;
16765  }
16766 
16767  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
16769  StrRef memo() const
16771  {
16772  return getVariableLengthField(memoAccess(), *this);
16773  }
16774 
16775  /// Free ASCII format text string.
16777  StrRef text() const
16779  {
16780  return getVariableLengthField(textAccess(), *this);
16781  }
16782 
16783  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
16784  ThisType& setMemo(StrRef value)
16785  {
16786  setVariableLengthField(
16787  memoAccess(),
16788  value,
16789  *this);
16790 
16791  return *this;
16792  }
16793 
16794  /// Free ASCII format text string.
16795  ThisType& setText(StrRef value)
16796  {
16797  setVariableLengthField(
16798  textAccess(),
16799  value,
16800  *this);
16801 
16802  return *this;
16803  }
16804 
16805  /// Minimal size of message body in bytes.
16808  static
16809  BlockLength
16813  {
16814  return
16815  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
16816  36;
16817  }
16818 
16819  /// Size of message body in bytes.
16822  static
16823  BlockLength
16827  {
16828  return
16829  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
16830  minimalBlockLength(version);
16831  }
16832 
16833  /// Minimal variable fields size (when variable-length fields are empty).
16837  static
16838  MessageSize
16841  {
16842  return
16843  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
16844  static_cast<MessageSize>(MemoEncoding::Size) + static_cast<MessageSize>(TextEncoding::Size);
16845  }
16846 
16847  /// Maximal message size.
16851  static UInt64 getMaxMessageSize(UInt8)
16853  {
16854  return
16856  }
16857 
16858  /// Reset all variable-length fields if any.
16861  {
16862  setMemoToNull();
16863  setTextToNull();
16864  return *this;
16865  }
16866 
16867  /// Reset all variable-length and optional fields if any.
16868  ThisType& reset()
16870  {
16871  setBusinessRejectRefIdToNull();
16872 
16873  resetVariableFields();
16874  return *this;
16875  }
16876 
16877  /// \return class name.
16881  static const Char* className()
16882  {
16883  return "BusinessMessageReject206";
16884  }
16885 
16886  /// FIX message type.
16890  static StrRef fixType()
16892  {
16893  return constructStrRef(
16894  "BusinessMessageReject206");
16895  }
16896 
16897  /// \return a human-readable presentation.
16899  std::string toString() const;
16900 
16901  /// \return the end of the message.
16903  const void* tail() const
16905  {
16906  return
16907  toOpaquePtr(
16908  (text().end()));
16909  }
16910 
16911  /// \return the size occupied by the message.
16915  {
16916  return
16917  SbeMessage::calculateBinarySize(tail());
16918  }
16919 
16920 private:
16921  void checkLength(
16922  EncodedLength length, SchemaVersion version) const
16923  {
16924  const EncodedLength minimalRequiredLength =
16925  minimalBlockLength(version) +
16926  MessageHeader::Size +
16927  getMinimalVariableFieldsSize(version);
16928 
16929  checkBinaryLength(
16930  *this, length, minimalRequiredLength);
16931  }
16932 
16933  /// Checks variable fields consistency.
16934  void checkVarLenFields() const
16935  {
16936  variableLengthFields().
16937  checkTail<MemoEncoding>().
16938  checkTail<TextEncoding>();
16939  }
16940 
16941  void checkCompatibility() const
16942  {
16943  assert(TemplateId == templateId());
16944 
16945  checkSchema<Schema>(schemaId(), version());
16946  checkLength(bufferSize(), version());
16947  checkVarLenFields();
16948  }
16949 
16950  /// Access helper.
16951  struct memoAccess
16952  {
16953  MemoEncoding&
16954  operator()(
16955  const BusinessMessageReject206& obj) const
16957  {
16958  return obj.
16959  variableLengthFields().
16960  head<MemoEncoding>();
16961  }
16962  };
16963 
16964  /// Access helper.
16965  struct textAccess
16966  {
16967  TextEncoding&
16968  operator()(
16969  const BusinessMessageReject206& obj) const
16971  {
16972  return obj.
16973  variableLengthFields().
16974  tail<MemoEncoding>().
16975  head<TextEncoding>();
16976  }
16977  };
16978 
16979  /// Reset the field.
16980  /// All the following data will be invalidated.
16981  ThisType& setMemoToNull()
16983  {
16984  setVariableLengthFieldToNull(memoAccess(), *this);
16985 
16986  return *this;
16987  }
16988 
16989  /// Reset the field.
16990  /// All the following data will be invalidated.
16991  ThisType& setTextToNull()
16993  {
16994  setVariableLengthFieldToNull(textAccess(), *this);
16995 
16996  return *this;
16997  }
16998 };
16999 
17000 /// The SecurityDefinitionRequest message creates a User Defined Spread (UDS) instrument. User-Defined Spreads provide users of the electronic trading platform the ability to create strategies composed by their choice of leg instruments, leg ratio and leg side.
17003 : SbeMessage
17004 {
17005  /// Used template schema.
17007 
17008  /// This type alias.
17010 
17011  /// Message template ID from SBE schema.
17012  enum { TemplateId = 300 };
17013 
17014  /// Repeating group dimensions.
17015  /// Entry of LegsEntry repeating group.
17018  <
17020  >
17021  {
17022  /// Base class type.
17023  typedef
17025  <
17027  >
17029 
17030  /// This type alias.
17032 
17033  /// Initializes instance of given
17034  /// version over given memory block.
17036  void* data,
17037  EncodedLength length,
17038  SchemaVersion version)
17039  : Base(data, numericCast<Base::BlockLength>(length), version)
17040  {
17041  assert(version >= Schema::MinimalVersion);
17042  assert(length >= minimalBlockLength(version));
17043  }
17044 
17045  /// Reset all variable-length fields if any.
17048  {
17049  return *this;
17050  }
17051 
17052  /// Reset all variable-length and optional fields if any.
17053  ThisType& reset()
17055  {
17056  setLegSideToNull();
17057 
17058  resetVariableFields();
17059  return *this;
17060  }
17061 
17062  /// Multileg instrument's individual security’s Symbol. See
17063  /// Symbol (55) field for description.
17067  {
17070 
17071  return fixedStr<length>(offset);
17072  }
17073 
17074  /// Multileg instrument's individual security’s Symbol. See
17075  /// Symbol (55) field for description.
17076  ThisType& setLegSymbol(StrRef value)
17078  {
17081 
17082  setFixedStr<length>(offset, value);
17083  return *this;
17084  }
17085 
17086  /// Exchange code the leg security belongs to.
17092  {
17093  return constructStrRef("BVMF");
17094  }
17095 
17096  /// The ratio of quantity for this individual leg relative to
17097  /// the entire multileg security.
17101  {
17103 
17104  return decimal<RatioQty>(offset);
17105  }
17106 
17107  /// The ratio of quantity for this individual leg relative to
17108  /// the entire multileg security.
17109  ThisType& setLegRatioQty(RatioQty value)
17111  {
17113 
17114  setOrdinary(offset, value);
17115  return *this;
17116  }
17117 
17118  /// The side of this individual leg (multileg security). See
17119  /// Side (54) field for description and values.
17121  bool legSide(Side::Enum& value) const
17123  {
17125 
17126  return enumeration<Side>(value, offset, NullChar());
17127  }
17128 
17129  /// The side of this individual leg (multileg security). See
17130  /// Side (54) field for description and values.
17131  ThisType& setLegSide(Side::Enum value)
17133  {
17135 
17136  setEnumeration<Side>(offset, value);
17137  return *this;
17138  }
17139 
17140  ThisType& setLegSideToNull()
17142  {
17144 
17145  setOrdinary(offset, NullChar());
17146  return *this;
17147  }
17148 
17149  /// \return size of entry body in bytes
17150  /// for given version of message template.
17153  static
17154  BlockLength
17158  {
17159  return
17160  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
17161  30;
17162  }
17163 
17164  /// \return minimal size of entry body in bytes
17165  /// for given version of message template.
17168  static
17169  BlockLength
17173  {
17174  return
17175  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
17176  29;
17177  }
17178 
17179  /// Entity class name.
17183  static const Char* className()
17184  {
17185  return "SecurityDefinitionRequest300.LegsEntry";
17186  }
17187  };
17188 
17189  /// Repeating group containing LegsEntry entries.
17190  typedef
17193 
17194  /// Initializes a blank instance.
17196 
17197  /// Initializes an instance over the given memory block.
17199  void* data,
17200  EncodedLength length,
17201  SchemaVersion version = Schema::Version)
17202  : SbeMessage(data, length, version)
17203  {
17204  checkVersion<Schema>(version);
17205  checkLength(length, version);
17206  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
17207  reset();
17208  }
17209 
17210  /// Initializes an instance over the given memory block
17211  /// With no variable-length fields initialization
17212  /// It is assumed that the user does such an initialization manually.
17214  void* data,
17215  EncodedLength length,
17216  NoFieldsInit,
17217  SchemaVersion version = Schema::Version)
17218  : SbeMessage(data, length, version)
17219  {
17220  checkVersion<Schema>(version);
17221  checkLength(length, version);
17222  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
17223  resetVariableFields();
17224  }
17225 
17226  /// Creates an instance over the given memory block.
17228  void* data,
17229  EncodedLength length,
17230  NoInit)
17231  : SbeMessage(data, length)
17232  {
17233  checkCompatibility();
17234  }
17235 
17236  /// Creates an instance over the given SBE message.
17237  explicit
17239  const SbeMessage& message)
17240  : SbeMessage(message)
17241  {
17242  assert(message.valid());
17243 
17244  checkCompatibility();
17245  }
17246 
17247  /// Creates an instance over the given memory block.
17248  /// Performs no checks.
17250  void* data,
17251  EncodedLength length,
17252  NoInit,
17253  NoCheck)
17255  : SbeMessage(data, length, NoCheck())
17256  {
17257  assert(schemaId() == Schema::Id);
17258  assert(version() >= Schema::MinimalVersion);
17259  assert(TemplateId == templateId());
17260  }
17261 
17262  /// Message type = SecurityDefinitionRequest.
17267  {
17268  return MessageType::SecurityDefinitionRequest;
17269  }
17270 
17271  /// Message type = SecurityDefinitionRequest.
17272 
17273  /// Common header to all inbound business messages.
17275  const InboundBusinessHeader&
17278  {
17280 
17281  return accessOrdinary<InboundBusinessHeader>(offset);
17282  }
17283 
17284  /// Common header to all inbound business messages.
17287  {
17289  return accessOrdinary<InboundBusinessHeader>(offset);
17290  }
17291 
17292  /// Unique ID of a Security Definition Request.
17296  {
17298 
17299  return ordinary<SecurityReqRespID>(offset);
17300  }
17301 
17302  /// Unique ID of a Security Definition Request.
17305  {
17307 
17308  setOrdinary(offset, value);
17309  return *this;
17310  }
17311 
17312  /// Identifies the original location for routing orders.
17316  {
17319 
17320  return fixedStr<length>(offset);
17321  }
17322 
17323  /// Identifies the original location for routing orders.
17324  ThisType& setSenderLocation(StrRef value)
17326  {
17329 
17330  setFixedStr<length>(offset, value);
17331  return *this;
17332  }
17333 
17334  /// Identifies the trader who is inserting an order.
17338  {
17341 
17342  return fixedStr<length>(offset);
17343  }
17344 
17345  /// Identifies the trader who is inserting an order.
17346  ThisType& setEnteringTrader(StrRef value)
17348  {
17351 
17352  setFixedStr<length>(offset, value);
17353  return *this;
17354  }
17355 
17356  /// \return instance of Legs repeating group.
17358  Legs legs() const
17360  {
17361  return getGroup<Legs>(LegsAccess(), *this);
17362  }
17363 
17364  /// \return instance of Legs repeating group.
17368  {
17369  return getGroup<Legs>(LegsAccess(), *this);
17370  }
17371 
17372  /// Setup repeating group with the given number of entries.
17373  /// Sets all optional fields of the group entries to null.
17374  /// \return noLegs(555) repeating group.
17376  {
17377  return constructGroup<Legs>(
17378  LegsAccess(),
17379  length,
17380  *this);
17381  }
17382 
17383  /// Setup repeating group with the given number of entries.
17384  /// \return noLegs(555) repeating group.
17385  Legs
17387  Legs::Size length,
17388  NoFieldsInit)
17389  {
17390  return setupGroup<Legs>(
17391  LegsAccess(),
17392  length,
17393  *this);
17394  }
17395 
17396  /// Minimal size of message body in bytes.
17399  static
17400  BlockLength
17404  {
17405  return
17406  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
17407  41;
17408  }
17409 
17410  /// Size of message body in bytes.
17415  {
17416  return
17417  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
17418  minimalBlockLength(version);
17419  }
17420 
17421  /// Minimal variable fields size (when variable-length fields are empty).
17425  static
17426  MessageSize
17429  {
17430  return
17431  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
17432  static_cast<MessageSize>(Legs::EmptySize);
17433  }
17434 
17435  /// Maximal message size.
17439  static
17440  UInt64
17442  UInt8 maxGroupItems = 255)
17444  {
17445  return
17446  static_cast<UInt64>(MessageHeaderBuilder::Size) +
17447  blockLength(Schema::Version) +
17448  (GroupSizeEncoding::Size + LegsEntry::blockLength(Schema::Version) * static_cast<UInt64>(maxGroupItems));
17449  }
17450 
17451  /// Reset all variable-length fields if any.
17454  {
17455  setLegsToNull();
17456  return *this;
17457  }
17458 
17459  /// Reset all variable-length and optional fields if any.
17460  ThisType& reset()
17462  {
17463  resetVariableFields();
17464  return *this;
17465  }
17466 
17467  /// \return class name.
17471  static const Char* className()
17472  {
17473  return "SecurityDefinitionRequest300";
17474  }
17475 
17476  /// FIX message type.
17480  static StrRef fixType()
17482  {
17483  return constructStrRef(
17484  "SecurityDefinitionRequest300");
17485  }
17486 
17487  /// \return a human-readable presentation.
17489  std::string toString() const;
17490 
17491  /// \return the end of the message.
17493  const void* tail() const
17495  {
17496  return
17497  legs().tail();
17498  }
17499 
17500  /// \return the size occupied by the message.
17504  {
17505  return
17506  SbeMessage::calculateBinarySize(tail());
17507  }
17508 
17509 private:
17510  void checkLength(
17511  EncodedLength length, SchemaVersion version) const
17512  {
17513  const EncodedLength minimalRequiredLength =
17514  minimalBlockLength(version) +
17515  MessageHeader::Size +
17516  getMinimalVariableFieldsSize(version);
17517 
17518  checkBinaryLength(
17519  *this, length, minimalRequiredLength);
17520  }
17521 
17522  /// Checks variable fields consistency.
17523  void checkVarLenFields() const
17524  {
17525  groups().
17526  checkTail<Legs>();
17527  }
17528 
17529  void checkCompatibility() const
17530  {
17531  assert(TemplateId == templateId());
17532 
17533  checkSchema<Schema>(schemaId(), version());
17534  checkLength(bufferSize(), version());
17535  checkVarLenFields();
17536  }
17537 
17538  /// Access helper.
17539  struct LegsAccess
17540  {
17541  Legs
17542  operator()(
17543  const SecurityDefinitionRequest300& obj) const
17545  {
17546  return obj.
17547  groups().
17548  head<Legs>();
17549  }
17550  };
17551 
17552  /// Reset an instance of the repeating group.
17553  /// All the following data will be invalidated.
17554  void setLegsToNull()
17556  {
17557  resetGroup<Legs>(LegsAccess(), *this);
17558  }
17559 };
17560 
17561 /// The SecurityDefinitioresponse message is sent in response to an attempt to create a new security definition.
17564 : SbeMessage
17565 {
17566  /// Used template schema.
17568 
17569  /// This type alias.
17571 
17572  /// Message template ID from SBE schema.
17573  enum { TemplateId = 301 };
17574 
17575  /// Initializes a blank instance.
17577 
17578  /// Initializes an instance over the given memory block.
17580  void* data,
17581  EncodedLength length,
17582  SchemaVersion version = Schema::Version)
17583  : SbeMessage(data, length, version)
17584  {
17585  checkVersion<Schema>(version);
17586  checkLength(length, version);
17587  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
17588  reset();
17589  }
17590 
17591  /// Initializes an instance over the given memory block
17592  /// With no variable-length fields initialization
17593  /// It is assumed that the user does such an initialization manually.
17595  void* data,
17596  EncodedLength length,
17597  NoFieldsInit,
17598  SchemaVersion version = Schema::Version)
17599  : SbeMessage(data, length, version)
17600  {
17601  checkVersion<Schema>(version);
17602  checkLength(length, version);
17603  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
17604  resetVariableFields();
17605  }
17606 
17607  /// Creates an instance over the given memory block.
17609  void* data,
17610  EncodedLength length,
17611  NoInit)
17612  : SbeMessage(data, length)
17613  {
17614  checkCompatibility();
17615  }
17616 
17617  /// Creates an instance over the given SBE message.
17618  explicit
17620  const SbeMessage& message)
17621  : SbeMessage(message)
17622  {
17623  assert(message.valid());
17624 
17625  checkCompatibility();
17626  }
17627 
17628  /// Creates an instance over the given memory block.
17629  /// Performs no checks.
17631  void* data,
17632  EncodedLength length,
17633  NoInit,
17634  NoCheck)
17636  : SbeMessage(data, length, NoCheck())
17637  {
17638  assert(schemaId() == Schema::Id);
17639  assert(version() >= Schema::MinimalVersion);
17640  assert(TemplateId == templateId());
17641  }
17642 
17643  /// Message type = SecurityDefinitionResponse.
17648  {
17649  return MessageType::SecurityDefinitionResponse;
17650  }
17651 
17652  /// Message type = SecurityDefinitionResponse.
17653 
17654  /// Common header to all outbound business messages.
17656  const OutboundBusinessHeader&
17659  {
17661 
17662  return accessOrdinary<OutboundBusinessHeader>(offset);
17663  }
17664 
17665  /// Common header to all outbound business messages.
17668  {
17670  return accessOrdinary<OutboundBusinessHeader>(offset);
17671  }
17672 
17673  /// Unique ID of a Security Definition Request.
17677  {
17679 
17680  return ordinary<SecurityReqRespID>(offset);
17681  }
17682 
17683  /// Unique ID of a Security Definition Request.
17686  {
17688 
17689  setOrdinary(offset, value);
17690  return *this;
17691  }
17692 
17693  /// Security identification as defined by exchange.
17695  bool
17697  SecurityIDOptional& value) const
17699  {
17701 
17702  return ordinary(value, offset, NullSecurityIDOptional());
17703  }
17704 
17705  /// Security identification as defined by exchange.
17708  {
17710 
17711  setOrdinary(offset, value);
17712  return *this;
17713  }
17714 
17717  {
17719 
17720  setOrdinary(offset, NullSecurityIDOptional());
17721  return *this;
17722  }
17723 
17724  /// Identifies the class of the SecurityID (Exchange Symbol).
17729  {
17730  return SecurityIDSource::ExchangeSymbol;
17731  }
17732 
17733  /// Identifies the class of the SecurityID (Exchange Symbol).
17734 
17735  /// Market to which the symbol belongs.
17741  {
17742  return constructStrRef("BVMF");
17743  }
17744 
17745  /// Type of Security Definition message response.
17750  {
17752 
17753  return enumeration<SecurityResponseType>(offset);
17754  }
17755 
17756  /// Type of Security Definition message response.
17757  ThisType&
17761  {
17763 
17764  setEnumeration<SecurityResponseType>(offset, value);
17765  return *this;
17766  }
17767 
17768  /// Indicates the type of Strategy created. This field is not
17769  /// sent on rejects.
17771  bool securityStrategyType(StrRef& value) const
17773  {
17776 
17777  return fixedStr<length>(value, offset);
17778  }
17779 
17780  /// Indicates the type of Strategy created. This field is not
17781  /// sent on rejects.
17784  {
17787 
17788  setFixedStr<length>(offset, value);
17789  return *this;
17790  }
17791 
17794  {
17797 
17798  setFixedStr<length>(offset, StrRef());
17799  return *this;
17800  }
17801 
17802  /// B3 requires that this field is properly set. It contains
17803  /// the human readable form of the SecurityID tag, available
17804  /// in the Security List message in Market Data feed.
17806  StrRef symbol() const
17808  {
17811 
17812  return fixedStr<length>(offset);
17813  }
17814 
17815  /// B3 requires that this field is properly set. It contains
17816  /// the human readable form of the SecurityID tag, available
17817  /// in the Security List message in Market Data feed.
17818  ThisType& setSymbol(StrRef value)
17820  {
17823 
17824  setFixedStr<length>(offset, value);
17825  return *this;
17826  }
17827 
17828  /// Unique ID of a Security Definition message.
17832  {
17834 
17835  return ordinary<SecurityReqRespID>(offset);
17836  }
17837 
17838  /// Unique ID of a Security Definition message.
17841  {
17843 
17844  setOrdinary(offset, value);
17845  return *this;
17846  }
17847 
17848  /// Identifies the original location for routing orders.
17852  {
17855 
17856  return fixedStr<length>(offset);
17857  }
17858 
17859  /// Identifies the original location for routing orders.
17860  ThisType& setSenderLocation(StrRef value)
17862  {
17865 
17866  setFixedStr<length>(offset, value);
17867  return *this;
17868  }
17869 
17870  /// Identifies the trader who is inserting an order.
17874  {
17877 
17878  return fixedStr<length>(offset);
17879  }
17880 
17881  /// Identifies the trader who is inserting an order.
17882  ThisType& setEnteringTrader(StrRef value)
17884  {
17887 
17888  setFixedStr<length>(offset, value);
17889  return *this;
17890  }
17891 
17892  /// Minimal size of message body in bytes.
17895  static
17896  BlockLength
17900  {
17901  return
17902  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
17903  83;
17904  }
17905 
17906  /// Size of message body in bytes.
17909  static
17910  BlockLength
17914  {
17915  return
17916  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
17917  minimalBlockLength(version);
17918  }
17919 
17920  /// Minimal variable fields size (when variable-length fields are empty).
17924  static
17925  MessageSize
17928  {
17929  return
17930  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
17931  0;
17932  }
17933 
17934  /// Maximal message size.
17938  static UInt64 getMaxMessageSize(UInt8)
17940  {
17941  return
17942  static_cast<UInt64>(MessageHeaderBuilder::Size) +
17943  blockLength(Schema::Version);
17944  }
17945 
17946  /// Reset all variable-length fields if any.
17949  {
17950  return *this;
17951  }
17952 
17953  /// Reset all variable-length and optional fields if any.
17954  ThisType& reset()
17956  {
17957  setSecurityIdToNull();
17958  setSecurityStrategyTypeToNull();
17959 
17960  resetVariableFields();
17961  return *this;
17962  }
17963 
17964  /// \return class name.
17968  static const Char* className()
17969  {
17970  return "SecurityDefinitionResponse301";
17971  }
17972 
17973  /// FIX message type.
17977  static StrRef fixType()
17979  {
17980  return constructStrRef(
17981  "SecurityDefinitionResponse301");
17982  }
17983 
17984  /// \return a human-readable presentation.
17986  std::string toString() const;
17987 
17988  /// \return the end of the message.
17990  const void* tail() const
17992  {
17993  return
17994  toOpaquePtr(
17995  advanceByBytes(
17996  binary(),
17997  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
17998  MessageHeader::Size));
17999  }
18000 
18001  /// \return the size occupied by the message.
18005  {
18006  return
18007  SbeMessage::calculateBinarySize(tail());
18008  }
18009 
18010 private:
18011  void checkLength(
18012  EncodedLength length, SchemaVersion version) const
18013  {
18014  const EncodedLength minimalRequiredLength =
18015  minimalBlockLength(version) +
18016  MessageHeader::Size +
18017  getMinimalVariableFieldsSize(version);
18018 
18019  checkBinaryLength(
18020  *this, length, minimalRequiredLength);
18021  }
18022 
18023  void checkCompatibility() const
18024  {
18025  assert(TemplateId == templateId());
18026 
18027  checkSchema<Schema>(schemaId(), version());
18028  checkLength(bufferSize(), version());
18029  }
18030 };
18031 
18032 /// The Quote Request message is used within the context of this Forward transaction in which two parties have completed a deal outside the Exchange and are initiating the negotiation process to formalize and execute this operation on the Exchange.
18035 : SbeMessage
18036 {
18037  /// Used template schema.
18039 
18040  /// This type alias.
18042 
18043  /// Message template ID from SBE schema.
18044  enum { TemplateId = 401 };
18045 
18046  /// Repeating group dimensions.
18047  /// Entry of SidesEntry repeating group.
18050  <
18052  >
18053  {
18054  /// Base class type.
18055  typedef
18057  <
18059  >
18061 
18062  /// This type alias.
18064 
18065  /// Initializes instance of given
18066  /// version over given memory block.
18068  void* data,
18069  EncodedLength length,
18070  SchemaVersion version)
18071  : Base(data, numericCast<Base::BlockLength>(length), version)
18072  {
18073  assert(version >= Schema::MinimalVersion);
18074  assert(length >= minimalBlockLength(version));
18075  }
18076 
18077  /// Reset all variable-length fields if any.
18080  {
18081  return *this;
18082  }
18083 
18084  /// Reset all variable-length and optional fields if any.
18085  ThisType& reset()
18087  {
18088  setAccountToNull();
18089 
18090  if (version() >= 5)
18091  {
18092  setTradingSubAccountToNull();
18093  }
18094 
18095  resetVariableFields();
18096  return *this;
18097  }
18098 
18099  /// Side of order.
18103  {
18105 
18106  return enumeration<Side>(offset);
18107  }
18108 
18109  /// Side of order.
18110  ThisType& setSide(Side::Enum value)
18112  {
18114 
18115  setEnumeration<Side>(offset, value);
18116  return *this;
18117  }
18118 
18119  /// Account mnemonic of the order.
18121  bool account(AccountOptional& value) const
18123  {
18125 
18126  return ordinary(value, offset, NullAccountOptional());
18127  }
18128 
18129  /// Account mnemonic of the order.
18130  ThisType& setAccount(AccountOptional value)
18132  {
18134 
18135  setOrdinary(offset, value);
18136  return *this;
18137  }
18138 
18139  ThisType& setAccountToNull()
18141  {
18143 
18144  setOrdinary(offset, NullAccountOptional());
18145  return *this;
18146  }
18147 
18148  /// Account used for associating risk limits (when defined).
18152  {
18155 
18156  return ordinary(value, offset, NullAccountOptional(), since);
18157  }
18158 
18159  /// Account used for associating risk limits (when defined).
18161  {
18164 
18165  setOrdinary(offset, value, since);
18166  return *this;
18167  }
18168 
18170  {
18173 
18174  setOrdinary(offset, NullAccountOptional(), since);
18175  return *this;
18176  }
18177 
18178  /// \return size of entry body in bytes
18179  /// for given version of message template.
18184  {
18185  return
18186  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
18187  minimalBlockLength(version);
18188  }
18189 
18190  /// \return minimal size of entry body in bytes
18191  /// for given version of message template.
18196  {
18197  return
18198  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
18199  (version >= 5)
18200  ? 9
18201  : 5;
18202  }
18203 
18204  /// Entity class name.
18208  static const Char* className()
18209  {
18210  return "QuoteRequest401.SidesEntry";
18211  }
18212  };
18213 
18214  /// Repeating group containing SidesEntry entries.
18215  typedef
18218 
18219  /// Initializes a blank instance.
18221 
18222  /// Initializes an instance over the given memory block.
18224  void* data,
18225  EncodedLength length,
18226  SchemaVersion version = Schema::Version)
18227  : SbeMessage(data, length, version)
18228  {
18229  checkVersion<Schema>(version);
18230  checkLength(length, version);
18231  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
18232  reset();
18233  }
18234 
18235  /// Initializes an instance over the given memory block
18236  /// With no variable-length fields initialization
18237  /// It is assumed that the user does such an initialization manually.
18239  void* data,
18240  EncodedLength length,
18241  NoFieldsInit,
18242  SchemaVersion version = Schema::Version)
18243  : SbeMessage(data, length, version)
18244  {
18245  checkVersion<Schema>(version);
18246  checkLength(length, version);
18247  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
18248  resetVariableFields();
18249  }
18250 
18251  /// Creates an instance over the given memory block.
18253  void* data,
18254  EncodedLength length,
18255  NoInit)
18256  : SbeMessage(data, length)
18257  {
18258  checkCompatibility();
18259  }
18260 
18261  /// Creates an instance over the given SBE message.
18262  explicit
18264  const SbeMessage& message)
18265  : SbeMessage(message)
18266  {
18267  assert(message.valid());
18268 
18269  checkCompatibility();
18270  }
18271 
18272  /// Creates an instance over the given memory block.
18273  /// Performs no checks.
18275  void* data,
18276  EncodedLength length,
18277  NoInit,
18278  NoCheck)
18280  : SbeMessage(data, length, NoCheck())
18281  {
18282  assert(schemaId() == Schema::Id);
18283  assert(version() >= Schema::MinimalVersion);
18284  assert(TemplateId == templateId());
18285  }
18286 
18287  /// Message type = QuoteRequest.
18292  {
18293  return MessageType::QuoteRequest;
18294  }
18295 
18296  /// Message type = QuoteRequest.
18297 
18298  /// Common header to all bidirectional business messages.
18303  {
18305 
18306  return accessOrdinary<BidirectionalBusinessHeader>(offset);
18307  }
18308 
18309  /// Common header to all bidirectional business messages.
18313  {
18315  return accessOrdinary<BidirectionalBusinessHeader>(offset);
18316  }
18317 
18318  /// Security identification as defined by exchange.
18322  {
18324 
18325  return ordinary<SecurityID>(offset);
18326  }
18327 
18328  /// Security identification as defined by exchange.
18329  ThisType& setSecurityId(SecurityID value)
18331  {
18333 
18334  setOrdinary(offset, value);
18335  return *this;
18336  }
18337 
18338  /// Identifies the class of the SecurityID (Exchange Symbol).
18343  {
18344  return SecurityIDSource::ExchangeSymbol;
18345  }
18346 
18347  /// Identifies the class of the SecurityID (Exchange Symbol).
18348 
18349  /// Market to which the symbol belongs.
18355  {
18356  return constructStrRef("BVMF");
18357  }
18358 
18359  /// Unique identifier for quote request.
18363  {
18365 
18366  return ordinary<QuoteReqID>(offset);
18367  }
18368 
18369  /// Unique identifier for quote request.
18370  ThisType& setQuoteReqId(QuoteReqID value)
18372  {
18374 
18375  setOrdinary(offset, value);
18376  return *this;
18377  }
18378 
18379  /// Unique identifier for quote.
18381  bool quoteId(QuoteIDOptional& value) const
18383  {
18385 
18386  return ordinary(value, offset, NullQuoteIDOptional());
18387  }
18388 
18389  /// Unique identifier for quote.
18390  ThisType& setQuoteId(QuoteIDOptional value)
18392  {
18394 
18395  setOrdinary(offset, value);
18396  return *this;
18397  }
18398 
18399  ThisType& setQuoteIdToNull()
18401  {
18403 
18404  setOrdinary(offset, NullQuoteIDOptional());
18405  return *this;
18406  }
18407 
18408  /// Contains the unique identifier for this trade, per
18409  /// instrument + trading date, as assigned by the exchange.
18411  bool tradeId(TradeIDOptional& value) const
18413  {
18415 
18416  return ordinary(value, offset, NullTradeIDOptional());
18417  }
18418 
18419  /// Contains the unique identifier for this trade, per
18420  /// instrument + trading date, as assigned by the exchange.
18421  ThisType& setTradeId(TradeIDOptional value)
18423  {
18425 
18426  setOrdinary(offset, value);
18427  return *this;
18428  }
18429 
18430  ThisType& setTradeIdToNull()
18432  {
18434 
18435  setOrdinary(offset, NullTradeIDOptional());
18436  return *this;
18437  }
18438 
18439  /// Broker identifier as assigned by B3 used to indicate the
18440  /// counterparty brokerage firm in a Forward deal.
18444  {
18446 
18447  return ordinary<Firm>(offset);
18448  }
18449 
18450  /// Broker identifier as assigned by B3 used to indicate the
18451  /// counterparty brokerage firm in a Forward deal.
18452  ThisType& setContraBroker(Firm value)
18454  {
18456 
18457  setOrdinary(offset, value);
18458  return *this;
18459  }
18460 
18461  /// Time of execution/order creation.
18465  {
18467 
18468  return ordinary<UTCTimestampNanos>(offset);
18469  }
18470 
18471  /// Time of execution/order creation.
18474  {
18476 
18477  setOrdinary(offset, value);
18478  return *this;
18479  }
18480 
18481  /// Price per share or contract. Conditionally required if the
18482  /// order type requires a price (not market orders and RLP).
18484  Price8 price() const
18486  {
18488 
18489  return decimal<Price8>(offset);
18490  }
18491 
18492  /// Price per share or contract. Conditionally required if the
18493  /// order type requires a price (not market orders and RLP).
18494  ThisType& setPrice(Price8 value)
18496  {
18498 
18499  setOrdinary(offset, value);
18500  return *this;
18501  }
18502 
18503  /// Indicates who in the contract has control over evoking
18504  /// settlement.
18508  {
18510 
18511  return enumeration<SettlType>(offset);
18512  }
18513 
18514  /// Indicates who in the contract has control over evoking
18515  /// settlement.
18518  {
18520 
18521  setEnumeration<SettlType>(offset, value);
18522  return *this;
18523  }
18524 
18525  /// Specifies if a simultaneous trade of the underlying is to
18526  /// be performed.Required to indicate Termo Vista and Termo
18527  /// Vista Registered.
18529  bool
18531  ExecuteUnderlyingTrade::Enum& value) const
18533  {
18535 
18536  return enumeration<ExecuteUnderlyingTrade>(value, offset, NullChar());
18537  }
18538 
18539  /// Specifies if a simultaneous trade of the underlying is to
18540  /// be performed.Required to indicate Termo Vista and Termo
18541  /// Vista Registered.
18542  ThisType&
18546  {
18548 
18549  setEnumeration<ExecuteUnderlyingTrade>(offset, value);
18550  return *this;
18551  }
18552 
18555  {
18557 
18558  setOrdinary(offset, NullChar());
18559  return *this;
18560  }
18561 
18562  /// Quantity ordered.
18566  {
18568 
18569  return ordinary<Quantity>(offset);
18570  }
18571 
18572  /// Quantity ordered.
18573  ThisType& setOrderQty(Quantity value)
18575  {
18577 
18578  setOrdinary(offset, value);
18579  return *this;
18580  }
18581 
18582  /// Identifies the original location for routing orders.
18586  {
18589 
18590  return fixedStr<length>(offset);
18591  }
18592 
18593  /// Identifies the original location for routing orders.
18594  ThisType& setSenderLocation(StrRef value)
18596  {
18599 
18600  setFixedStr<length>(offset, value);
18601  return *this;
18602  }
18603 
18604  /// Identifies the trader who is inserting an order.
18608  {
18611 
18612  return fixedStr<length>(offset);
18613  }
18614 
18615  /// Identifies the trader who is inserting an order.
18616  ThisType& setEnteringTrader(StrRef value)
18618  {
18621 
18622  setFixedStr<length>(offset, value);
18623  return *this;
18624  }
18625 
18626  /// Identifies the trader who is executing an order.
18630  {
18633 
18634  return fixedStr<length>(offset);
18635  }
18636 
18637  /// Identifies the trader who is executing an order.
18638  ThisType& setExecutingTrader(StrRef value)
18640  {
18643 
18644  setFixedStr<length>(offset, value);
18645  return *this;
18646  }
18647 
18648  /// Describes the interest to be paid by the forward buyer and
18649  /// received by the forward seller, in proportion to the
18650  /// agreed days to settlement. Expressed in decimal form. For
18651  /// example, 1% is expressed and sent as 0.01. One basis point
18652  /// is represented as 0.0001.
18656  {
18658 
18659  return decimal<Percentage8>(offset);
18660  }
18661 
18662  /// Describes the interest to be paid by the forward buyer and
18663  /// received by the forward seller, in proportion to the
18664  /// agreed days to settlement. Expressed in decimal form. For
18665  /// example, 1% is expressed and sent as 0.01. One basis point
18666  /// is represented as 0.0001.
18667  ThisType& setFixedRate(Percentage8 value)
18669  {
18671 
18672  setOrdinary(offset, value);
18673  return *this;
18674  }
18675 
18676  /// Specifies whether a quote is public, i.e. available to the
18677  /// market, or private, i.e. available to a specified
18678  /// counterparty only.
18683  {
18684  return Boolean::TrueValue;
18685  }
18686 
18687  /// Specifies whether a quote is public, i.e. available to the
18688  /// market, or private, i.e. available to a specified
18689  /// counterparty only.
18690 
18691  /// Deadline for completing the forward deal. For Common,
18692  /// Dollar and Index contracts must be between 16 and 999. And
18693  /// maximum of 90 days for Flexible.
18697  {
18699 
18700  return ordinary<DaysToSettlement>(offset);
18701  }
18702 
18703  /// Deadline for completing the forward deal. For Common,
18704  /// Dollar and Index contracts must be between 16 and 999. And
18705  /// maximum of 90 days for Flexible.
18708  {
18710 
18711  setOrdinary(offset, value);
18712  return *this;
18713  }
18714 
18715  /// \return instance of Sides repeating group.
18717  Sides sides() const
18719  {
18720  return getGroup<Sides>(SidesAccess(), *this);
18721  }
18722 
18723  /// \return instance of Sides repeating group.
18727  {
18728  return getGroup<Sides>(SidesAccess(), *this);
18729  }
18730 
18731  /// Setup repeating group with the given number of entries.
18732  /// Sets all optional fields of the group entries to null.
18733  /// \return noSides(35511) repeating group.
18735  {
18736  return constructGroup<Sides>(
18737  SidesAccess(),
18738  length,
18739  *this);
18740  }
18741 
18742  /// Setup repeating group with the given number of entries.
18743  /// \return noSides(35511) repeating group.
18744  Sides
18746  Sides::Size length,
18747  NoFieldsInit)
18748  {
18749  return setupGroup<Sides>(
18750  SidesAccess(),
18751  length,
18752  *this);
18753  }
18754 
18755  /// Identifies the trading desk.
18757  StrRef deskId() const
18759  {
18760  return getVariableLengthField(deskIDAccess(), *this);
18761  }
18762 
18763  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
18765  StrRef memo() const
18767  {
18768  return getVariableLengthField(memoAccess(), *this);
18769  }
18770 
18771  /// Identifies the trading desk.
18772  ThisType& setDeskId(StrRef value)
18773  {
18774  setVariableLengthField(
18775  deskIDAccess(),
18776  value,
18777  *this);
18778 
18779  return *this;
18780  }
18781 
18782  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
18783  ThisType& setMemo(StrRef value)
18784  {
18785  setVariableLengthField(
18786  memoAccess(),
18787  value,
18788  *this);
18789 
18790  return *this;
18791  }
18792 
18793  /// Minimal size of message body in bytes.
18796  static
18797  BlockLength
18801  {
18802  return
18803  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
18804  108;
18805  }
18806 
18807  /// Size of message body in bytes.
18812  {
18813  return
18814  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
18815  minimalBlockLength(version);
18816  }
18817 
18818  /// Minimal variable fields size (when variable-length fields are empty).
18822  static
18823  MessageSize
18826  {
18827  return
18828  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
18829  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size) + static_cast<MessageSize>(Sides::EmptySize);
18830  }
18831 
18832  /// Maximal message size.
18836  static UInt64 getMaxMessageSize(UInt8)
18838  {
18839  return
18841  }
18842 
18843  /// Reset all variable-length fields if any.
18846  {
18847  setSidesToNull();
18848  setDeskIdToNull();
18849  setMemoToNull();
18850  return *this;
18851  }
18852 
18853  /// Reset all variable-length and optional fields if any.
18854  ThisType& reset()
18856  {
18857  setQuoteIdToNull();
18858  setTradeIdToNull();
18859  setExecuteUnderlyingTradeToNull();
18860 
18861  resetVariableFields();
18862  return *this;
18863  }
18864 
18865  /// \return class name.
18869  static const Char* className()
18870  {
18871  return "QuoteRequest401";
18872  }
18873 
18874  /// FIX message type.
18878  static StrRef fixType()
18880  {
18881  return constructStrRef("QuoteRequest401");
18882  }
18883 
18884  /// \return a human-readable presentation.
18886  std::string toString() const;
18887 
18888  /// \return the end of the message.
18890  const void* tail() const
18892  {
18893  return
18894  toOpaquePtr(
18895  (memo().end()));
18896  }
18897 
18898  /// \return the size occupied by the message.
18902  {
18903  return
18904  SbeMessage::calculateBinarySize(tail());
18905  }
18906 
18907 private:
18908  void checkLength(
18909  EncodedLength length, SchemaVersion version) const
18910  {
18911  const EncodedLength minimalRequiredLength =
18912  minimalBlockLength(version) +
18913  MessageHeader::Size +
18914  getMinimalVariableFieldsSize(version);
18915 
18916  checkBinaryLength(
18917  *this, length, minimalRequiredLength);
18918  }
18919 
18920  /// Checks variable fields consistency.
18921  void checkVarLenFields() const
18922  {
18923  groups().
18924  checkVariableLengthFields<Sides>().
18925  checkTail<DeskIDEncoding>().
18926  checkTail<MemoEncoding>();
18927  }
18928 
18929  void checkCompatibility() const
18930  {
18931  assert(TemplateId == templateId());
18932 
18933  checkSchema<Schema>(schemaId(), version());
18934  checkLength(bufferSize(), version());
18935  checkVarLenFields();
18936  }
18937 
18938  /// Access helper.
18939  struct SidesAccess
18940  {
18941  Sides
18942  operator()(
18943  const QuoteRequest401& obj) const
18945  {
18946  return obj.
18947  groups().
18948  head<Sides>();
18949  }
18950  };
18951 
18952  /// Reset an instance of the repeating group.
18953  /// All the following data will be invalidated.
18954  void setSidesToNull()
18956  {
18957  resetGroup<Sides>(SidesAccess(), *this);
18958  }
18959 
18960  /// Access helper.
18961  struct deskIDAccess
18962  {
18964  operator()(
18965  const QuoteRequest401& obj) const
18967  {
18968  return obj.
18969  groups().
18970  variableLengthFields<Sides>().
18971  head<DeskIDEncoding>();
18972  }
18973  };
18974 
18975  /// Access helper.
18976  struct memoAccess
18977  {
18978  MemoEncoding&
18979  operator()(
18980  const QuoteRequest401& obj) const
18982  {
18983  return obj.
18984  groups().
18985  variableLengthFields<Sides>().
18986  tail<DeskIDEncoding>().
18987  head<MemoEncoding>();
18988  }
18989  };
18990 
18991  /// Reset the field.
18992  /// All the following data will be invalidated.
18993  ThisType& setDeskIdToNull()
18995  {
18996  setVariableLengthFieldToNull(deskIDAccess(), *this);
18997 
18998  return *this;
18999  }
19000 
19001  /// Reset the field.
19002  /// All the following data will be invalidated.
19003  ThisType& setMemoToNull()
19005  {
19006  setVariableLengthFieldToNull(memoAccess(), *this);
19007 
19008  return *this;
19009  }
19010 };
19011 
19012 /// The QuoteStatusReport message is to inform the current status of forward acceptance.
19015 : SbeMessage
19016 {
19017  /// Used template schema.
19019 
19020  /// This type alias.
19022 
19023  /// Message template ID from SBE schema.
19024  enum { TemplateId = 402 };
19025 
19026  /// Initializes a blank instance.
19028 
19029  /// Initializes an instance over the given memory block.
19031  void* data,
19032  EncodedLength length,
19033  SchemaVersion version = Schema::Version)
19034  : SbeMessage(data, length, version)
19035  {
19036  checkVersion<Schema>(version);
19037  checkLength(length, version);
19038  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
19039  reset();
19040  }
19041 
19042  /// Initializes an instance over the given memory block
19043  /// With no variable-length fields initialization
19044  /// It is assumed that the user does such an initialization manually.
19046  void* data,
19047  EncodedLength length,
19048  NoFieldsInit,
19049  SchemaVersion version = Schema::Version)
19050  : SbeMessage(data, length, version)
19051  {
19052  checkVersion<Schema>(version);
19053  checkLength(length, version);
19054  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
19055  resetVariableFields();
19056  }
19057 
19058  /// Creates an instance over the given memory block.
19060  void* data,
19061  EncodedLength length,
19062  NoInit)
19063  : SbeMessage(data, length)
19064  {
19065  checkCompatibility();
19066  }
19067 
19068  /// Creates an instance over the given SBE message.
19069  explicit
19071  const SbeMessage& message)
19072  : SbeMessage(message)
19073  {
19074  assert(message.valid());
19075 
19076  checkCompatibility();
19077  }
19078 
19079  /// Creates an instance over the given memory block.
19080  /// Performs no checks.
19082  void* data,
19083  EncodedLength length,
19084  NoInit,
19085  NoCheck)
19087  : SbeMessage(data, length, NoCheck())
19088  {
19089  assert(schemaId() == Schema::Id);
19090  assert(version() >= Schema::MinimalVersion);
19091  assert(TemplateId == templateId());
19092  }
19093 
19094  /// Message type = QuoteStatusReport.
19099  {
19100  return MessageType::QuoteStatusReport;
19101  }
19102 
19103  /// Message type = QuoteStatusReport.
19104 
19105  /// Common header to all bidirectional business messages.
19110  {
19112 
19113  return accessOrdinary<BidirectionalBusinessHeader>(offset);
19114  }
19115 
19116  /// Common header to all bidirectional business messages.
19120  {
19122  return accessOrdinary<BidirectionalBusinessHeader>(offset);
19123  }
19124 
19125  /// Reason Quote was rejected.
19129  {
19131 
19132  return ordinary(value, offset, NullRejReasonOptional());
19133  }
19134 
19135  /// Reason Quote was rejected.
19138  {
19140 
19141  setOrdinary(offset, value);
19142  return *this;
19143  }
19144 
19147  {
19149 
19150  setOrdinary(offset, NullRejReasonOptional());
19151  return *this;
19152  }
19153 
19154  /// Security identification as defined by exchange.
19158  {
19160 
19161  return ordinary<SecurityID>(offset);
19162  }
19163 
19164  /// Security identification as defined by exchange.
19165  ThisType& setSecurityId(SecurityID value)
19167  {
19169 
19170  setOrdinary(offset, value);
19171  return *this;
19172  }
19173 
19174  /// Identifies the class of the SecurityID (Exchange Symbol).
19179  {
19180  return SecurityIDSource::ExchangeSymbol;
19181  }
19182 
19183  /// Identifies the class of the SecurityID (Exchange Symbol).
19184 
19185  /// Market to which the symbol belongs.
19191  {
19192  return constructStrRef("BVMF");
19193  }
19194 
19195  /// Unique identifier for quote request.
19199  {
19201 
19202  return ordinary<QuoteReqID>(offset);
19203  }
19204 
19205  /// Unique identifier for quote request.
19206  ThisType& setQuoteReqId(QuoteReqID value)
19208  {
19210 
19211  setOrdinary(offset, value);
19212  return *this;
19213  }
19214 
19215  /// Unique identifier for quote.
19219  {
19221 
19222  return ordinary<QuoteID>(offset);
19223  }
19224 
19225  /// Unique identifier for quote.
19226  ThisType& setQuoteId(QuoteID value)
19228  {
19230 
19231  setOrdinary(offset, value);
19232  return *this;
19233  }
19234 
19235  /// Contains the unique identifier for this trade, per
19236  /// instrument + trading date, as assigned by the exchange.
19238  bool tradeId(TradeIDOptional& value) const
19240  {
19242 
19243  return ordinary(value, offset, NullTradeIDOptional());
19244  }
19245 
19246  /// Contains the unique identifier for this trade, per
19247  /// instrument + trading date, as assigned by the exchange.
19248  ThisType& setTradeId(TradeIDOptional value)
19250  {
19252 
19253  setOrdinary(offset, value);
19254  return *this;
19255  }
19256 
19257  ThisType& setTradeIdToNull()
19259  {
19261 
19262  setOrdinary(offset, NullTradeIDOptional());
19263  return *this;
19264  }
19265 
19266  /// Broker identifier as assigned by B3 used to indicate the
19267  /// counterparty brokerage firm in a Forward deal.
19271  {
19273 
19274  return ordinary<Firm>(offset);
19275  }
19276 
19277  /// Broker identifier as assigned by B3 used to indicate the
19278  /// counterparty brokerage firm in a Forward deal.
19279  ThisType& setContraBroker(Firm value)
19281  {
19283 
19284  setOrdinary(offset, value);
19285  return *this;
19286  }
19287 
19288  /// Time of execution/order creation.
19292  {
19294 
19295  return ordinary<UTCTimestampNanos>(offset);
19296  }
19297 
19298  /// Time of execution/order creation.
19301  {
19303 
19304  setOrdinary(offset, value);
19305  return *this;
19306  }
19307 
19308  /// Identifies the status of the quote acknowledgement.
19312  {
19314 
19315  return enumeration<QuoteStatus>(offset);
19316  }
19317 
19318  /// Identifies the status of the quote acknowledgement.
19321  {
19323 
19324  setEnumeration<QuoteStatus>(offset, value);
19325  return *this;
19326  }
19327 
19328  /// Identifies the type of request that a Quote Status Report
19329  /// is in response to.
19331  bool
19333  QuoteStatusResponseTo::Enum& value) const
19335  {
19337 
19338  return enumeration<QuoteStatusResponseTo>(value, offset, NullChar());
19339  }
19340 
19341  /// Identifies the type of request that a Quote Status Report
19342  /// is in response to.
19343  ThisType&
19347  {
19349 
19350  setEnumeration<QuoteStatusResponseTo>(offset, value);
19351  return *this;
19352  }
19353 
19356  {
19358 
19359  setOrdinary(offset, NullChar());
19360  return *this;
19361  }
19362 
19363  /// Account mnemonic of the order.
19365  bool account(AccountOptional& value) const
19367  {
19369 
19370  return ordinary(value, offset, NullAccountOptional());
19371  }
19372 
19373  /// Account mnemonic of the order.
19374  ThisType& setAccount(AccountOptional value)
19376  {
19378 
19379  setOrdinary(offset, value);
19380  return *this;
19381  }
19382 
19383  ThisType& setAccountToNull()
19385  {
19387 
19388  setOrdinary(offset, NullAccountOptional());
19389  return *this;
19390  }
19391 
19392  /// Side of order.
19394  bool side(Side::Enum& value) const
19396  {
19398 
19399  return enumeration<Side>(value, offset, NullChar());
19400  }
19401 
19402  /// Side of order.
19403  ThisType& setSide(Side::Enum value)
19405  {
19407 
19408  setEnumeration<Side>(offset, value);
19409  return *this;
19410  }
19411 
19412  ThisType& setSideToNull()
19414  {
19416 
19417  setOrdinary(offset, NullChar());
19418  return *this;
19419  }
19420 
19421  /// Indicates who in the contract has control over evoking
19422  /// settlement.
19424  bool settlType(SettlType::Enum& value) const
19426  {
19428 
19429  return enumeration<SettlType>(value, offset, NullChar());
19430  }
19431 
19432  /// Indicates who in the contract has control over evoking
19433  /// settlement.
19436  {
19438 
19439  setEnumeration<SettlType>(offset, value);
19440  return *this;
19441  }
19442 
19445  {
19447 
19448  setOrdinary(offset, NullChar());
19449  return *this;
19450  }
19451 
19452  /// Price per share or contract. Conditionally required if the
19453  /// order type requires a price (not market orders and RLP).
19455  bool price(Price8Optional& value) const
19457  {
19459 
19460  return decimal(value, offset, NullPrice8Optional());
19461  }
19462 
19463  /// Price per share or contract. Conditionally required if the
19464  /// order type requires a price (not market orders and RLP).
19465  ThisType& setPrice(Price8Optional value)
19467  {
19469 
19470  setOrdinary(offset, value);
19471  return *this;
19472  }
19473 
19474  ThisType& setPriceToNull()
19476  {
19478 
19479  setOrdinary(offset, NullPrice8Optional());
19480  return *this;
19481  }
19482 
19483  /// Quantity ordered.
19487  {
19489 
19490  return ordinary<Quantity>(offset);
19491  }
19492 
19493  /// Quantity ordered.
19494  ThisType& setOrderQty(Quantity value)
19496  {
19498 
19499  setOrdinary(offset, value);
19500  return *this;
19501  }
19502 
19503  /// Identifies the original location for routing orders.
19507  {
19510 
19511  return fixedStr<length>(offset);
19512  }
19513 
19514  /// Identifies the original location for routing orders.
19515  ThisType& setSenderLocation(StrRef value)
19517  {
19520 
19521  setFixedStr<length>(offset, value);
19522  return *this;
19523  }
19524 
19525  /// Identifies the trader who is inserting an order.
19529  {
19532 
19533  return fixedStr<length>(offset);
19534  }
19535 
19536  /// Identifies the trader who is inserting an order.
19537  ThisType& setEnteringTrader(StrRef value)
19539  {
19542 
19543  setFixedStr<length>(offset, value);
19544  return *this;
19545  }
19546 
19547  /// Identifies the trader who is executing an order.
19551  {
19554 
19555  return fixedStr<length>(offset);
19556  }
19557 
19558  /// Identifies the trader who is executing an order.
19559  ThisType& setExecutingTrader(StrRef value)
19561  {
19564 
19565  setFixedStr<length>(offset, value);
19566  return *this;
19567  }
19568 
19569  /// Interest rate of the forward trade.
19571  bool
19573  Percentage8Optional& value) const
19575  {
19577 
19578  return decimal(value, offset, NullPercentage8Optional());
19579  }
19580 
19581  /// Interest rate of the forward trade.
19582  ThisType&
19584  Percentage8Optional value)
19586  {
19588 
19589  setOrdinary(offset, value);
19590  return *this;
19591  }
19592 
19595  {
19597 
19598  setOrdinary(offset, NullPercentage8Optional());
19599  return *this;
19600  }
19601 
19602  /// Specifies if a simultaneous trade of the underlying is to
19603  /// be performed.Required to indicate Termo Vista and Termo
19604  /// Vista Registered.
19606  bool
19608  ExecuteUnderlyingTrade::Enum& value) const
19610  {
19612 
19613  return enumeration<ExecuteUnderlyingTrade>(value, offset, NullChar());
19614  }
19615 
19616  /// Specifies if a simultaneous trade of the underlying is to
19617  /// be performed.Required to indicate Termo Vista and Termo
19618  /// Vista Registered.
19619  ThisType&
19623  {
19625 
19626  setEnumeration<ExecuteUnderlyingTrade>(offset, value);
19627  return *this;
19628  }
19629 
19632  {
19634 
19635  setOrdinary(offset, NullChar());
19636  return *this;
19637  }
19638 
19639  /// Specifies whether a quote is public, i.e. available to the
19640  /// market, or private, i.e. available to a specified
19641  /// counterparty only.
19646  {
19647  return Boolean::TrueValue;
19648  }
19649 
19650  /// Specifies whether a quote is public, i.e. available to the
19651  /// market, or private, i.e. available to a specified
19652  /// counterparty only.
19653 
19654  /// Deadline for completing the forward deal. For Common,
19655  /// Dollar and Index contracts must be between 16 and 999. And
19656  /// maximum of 90 days for Flexible.
19658  bool
19660  DaysToSettlementOptional& value) const
19662  {
19664 
19665  return ordinary(value, offset, NullDaysToSettlementOptional());
19666  }
19667 
19668  /// Deadline for completing the forward deal. For Common,
19669  /// Dollar and Index contracts must be between 16 and 999. And
19670  /// maximum of 90 days for Flexible.
19671  ThisType&
19675  {
19677 
19678  setOrdinary(offset, value);
19679  return *this;
19680  }
19681 
19684  {
19686 
19687  setOrdinary(offset, NullDaysToSettlementOptional());
19688  return *this;
19689  }
19690 
19691  /// Account used for associating risk limits (when defined).
19695  {
19698 
19699  return ordinary(value, offset, NullAccountOptional(), since);
19700  }
19701 
19702  /// Account used for associating risk limits (when defined).
19704  {
19707 
19708  setOrdinary(offset, value, since);
19709  return *this;
19710  }
19711 
19713  {
19716 
19717  setOrdinary(offset, NullAccountOptional(), since);
19718  return *this;
19719  }
19720 
19721  /// Identifies the trading desk.
19723  StrRef deskId() const
19725  {
19726  return getVariableLengthField(deskIDAccess(), *this);
19727  }
19728 
19729  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
19731  StrRef memo() const
19733  {
19734  return getVariableLengthField(memoAccess(), *this);
19735  }
19736 
19737  /// Free ASCII format text string.
19739  StrRef text() const
19741  {
19742  return getVariableLengthField(textAccess(), *this);
19743  }
19744 
19745  /// Identifies the trading desk.
19746  ThisType& setDeskId(StrRef value)
19747  {
19748  setVariableLengthField(
19749  deskIDAccess(),
19750  value,
19751  *this);
19752 
19753  return *this;
19754  }
19755 
19756  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
19757  ThisType& setMemo(StrRef value)
19758  {
19759  setVariableLengthField(
19760  memoAccess(),
19761  value,
19762  *this);
19763 
19764  return *this;
19765  }
19766 
19767  /// Free ASCII format text string.
19768  ThisType& setText(StrRef value)
19769  {
19770  setVariableLengthField(
19771  textAccess(),
19772  value,
19773  *this);
19774 
19775  return *this;
19776  }
19777 
19778  /// Minimal size of message body in bytes.
19783  {
19784  return
19785  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
19786  (version >= 5)
19787  ? 123
19788  : 119;
19789  }
19790 
19791  /// Size of message body in bytes.
19796  {
19797  return
19798  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
19799  minimalBlockLength(version);
19800  }
19801 
19802  /// Minimal variable fields size (when variable-length fields are empty).
19806  static
19807  MessageSize
19810  {
19811  return
19812  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
19813  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size) + static_cast<MessageSize>(TextEncoding::Size);
19814  }
19815 
19816  /// Maximal message size.
19820  static UInt64 getMaxMessageSize(UInt8)
19822  {
19823  return
19825  }
19826 
19827  /// Reset all variable-length fields if any.
19830  {
19831  setDeskIdToNull();
19832  setMemoToNull();
19833  setTextToNull();
19834  return *this;
19835  }
19836 
19837  /// Reset all variable-length and optional fields if any.
19838  ThisType& reset()
19840  {
19841  setQuoteRejectReasonToNull();
19842  setTradeIdToNull();
19843  setQuoteStatusResponseToToNull();
19844  setAccountToNull();
19845  setSideToNull();
19846  setSettlTypeToNull();
19847  setPriceToNull();
19848  setFixedRateToNull();
19849  setExecuteUnderlyingTradeToNull();
19850  setDaysToSettlementToNull();
19851 
19852  if (version() >= 5)
19853  {
19854  setTradingSubAccountToNull();
19855  }
19856 
19857  resetVariableFields();
19858  return *this;
19859  }
19860 
19861  /// \return class name.
19865  static const Char* className()
19866  {
19867  return "QuoteStatusReport402";
19868  }
19869 
19870  /// FIX message type.
19874  static StrRef fixType()
19876  {
19877  return constructStrRef("QuoteStatusReport402");
19878  }
19879 
19880  /// \return a human-readable presentation.
19882  std::string toString() const;
19883 
19884  /// \return the end of the message.
19886  const void* tail() const
19888  {
19889  return
19890  toOpaquePtr(
19891  (text().end()));
19892  }
19893 
19894  /// \return the size occupied by the message.
19898  {
19899  return
19900  SbeMessage::calculateBinarySize(tail());
19901  }
19902 
19903 private:
19904  void checkLength(
19905  EncodedLength length, SchemaVersion version) const
19906  {
19907  const EncodedLength minimalRequiredLength =
19908  minimalBlockLength(version) +
19909  MessageHeader::Size +
19910  getMinimalVariableFieldsSize(version);
19911 
19912  checkBinaryLength(
19913  *this, length, minimalRequiredLength);
19914  }
19915 
19916  /// Checks variable fields consistency.
19917  void checkVarLenFields() const
19918  {
19919  variableLengthFields().
19920  checkTail<DeskIDEncoding>().
19921  checkTail<MemoEncoding>().
19922  checkTail<TextEncoding>();
19923  }
19924 
19925  void checkCompatibility() const
19926  {
19927  assert(TemplateId == templateId());
19928 
19929  checkSchema<Schema>(schemaId(), version());
19930  checkLength(bufferSize(), version());
19931  checkVarLenFields();
19932  }
19933 
19934  /// Access helper.
19935  struct deskIDAccess
19936  {
19938  operator()(
19939  const QuoteStatusReport402& obj) const
19941  {
19942  return obj.
19943  variableLengthFields().
19944  head<DeskIDEncoding>();
19945  }
19946  };
19947 
19948  /// Access helper.
19949  struct memoAccess
19950  {
19951  MemoEncoding&
19952  operator()(
19953  const QuoteStatusReport402& obj) const
19955  {
19956  return obj.
19957  variableLengthFields().
19958  tail<DeskIDEncoding>().
19959  head<MemoEncoding>();
19960  }
19961  };
19962 
19963  /// Access helper.
19964  struct textAccess
19965  {
19966  TextEncoding&
19967  operator()(
19968  const QuoteStatusReport402& obj) const
19970  {
19971  return obj.
19972  variableLengthFields().
19973  tail<DeskIDEncoding>().
19974  tail<MemoEncoding>().
19975  head<TextEncoding>();
19976  }
19977  };
19978 
19979  /// Reset the field.
19980  /// All the following data will be invalidated.
19981  ThisType& setDeskIdToNull()
19983  {
19984  setVariableLengthFieldToNull(deskIDAccess(), *this);
19985 
19986  return *this;
19987  }
19988 
19989  /// Reset the field.
19990  /// All the following data will be invalidated.
19991  ThisType& setMemoToNull()
19993  {
19994  setVariableLengthFieldToNull(memoAccess(), *this);
19995 
19996  return *this;
19997  }
19998 
19999  /// Reset the field.
20000  /// All the following data will be invalidated.
20001  ThisType& setTextToNull()
20003  {
20004  setVariableLengthFieldToNull(textAccess(), *this);
20005 
20006  return *this;
20007  }
20008 };
20009 
20010 /// Quote message is used as the response to a QuoteRequest message, tradeable, and restricted tradeable quoting markets.
20012 Quote403
20013 : SbeMessage
20014 {
20015  /// Used template schema.
20017 
20018  /// This type alias.
20020 
20021  /// Message template ID from SBE schema.
20022  enum { TemplateId = 403 };
20023 
20024  /// Initializes a blank instance.
20026 
20027  /// Initializes an instance over the given memory block.
20029  void* data,
20030  EncodedLength length,
20031  SchemaVersion version = Schema::Version)
20032  : SbeMessage(data, length, version)
20033  {
20034  checkVersion<Schema>(version);
20035  checkLength(length, version);
20036  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
20037  reset();
20038  }
20039 
20040  /// Initializes an instance over the given memory block
20041  /// With no variable-length fields initialization
20042  /// It is assumed that the user does such an initialization manually.
20044  void* data,
20045  EncodedLength length,
20046  NoFieldsInit,
20047  SchemaVersion version = Schema::Version)
20048  : SbeMessage(data, length, version)
20049  {
20050  checkVersion<Schema>(version);
20051  checkLength(length, version);
20052  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
20053  resetVariableFields();
20054  }
20055 
20056  /// Creates an instance over the given memory block.
20058  void* data,
20059  EncodedLength length,
20060  NoInit)
20061  : SbeMessage(data, length)
20062  {
20063  checkCompatibility();
20064  }
20065 
20066  /// Creates an instance over the given SBE message.
20067  explicit
20069  const SbeMessage& message)
20070  : SbeMessage(message)
20071  {
20072  assert(message.valid());
20073 
20074  checkCompatibility();
20075  }
20076 
20077  /// Creates an instance over the given memory block.
20078  /// Performs no checks.
20080  void* data,
20081  EncodedLength length,
20082  NoInit,
20083  NoCheck)
20085  : SbeMessage(data, length, NoCheck())
20086  {
20087  assert(schemaId() == Schema::Id);
20088  assert(version() >= Schema::MinimalVersion);
20089  assert(TemplateId == templateId());
20090  }
20091 
20092  /// Message type = TermoQuote.
20097  {
20098  return MessageType::Quote;
20099  }
20100 
20101  /// Message type = TermoQuote.
20102 
20103  /// Common header to all bidirectional business messages.
20108  {
20110 
20111  return accessOrdinary<BidirectionalBusinessHeader>(offset);
20112  }
20113 
20114  /// Common header to all bidirectional business messages.
20118  {
20120  return accessOrdinary<BidirectionalBusinessHeader>(offset);
20121  }
20122 
20123  /// Security identification as defined by exchange.
20127  {
20129 
20130  return ordinary<SecurityID>(offset);
20131  }
20132 
20133  /// Security identification as defined by exchange.
20134  ThisType& setSecurityId(SecurityID value)
20136  {
20138 
20139  setOrdinary(offset, value);
20140  return *this;
20141  }
20142 
20143  /// Identifies the class of the SecurityID (Exchange Symbol).
20148  {
20149  return SecurityIDSource::ExchangeSymbol;
20150  }
20151 
20152  /// Identifies the class of the SecurityID (Exchange Symbol).
20153 
20154  /// Market to which the symbol belongs.
20160  {
20161  return constructStrRef("BVMF");
20162  }
20163 
20164  /// Unique identifier for quote request.
20168  {
20170 
20171  return ordinary<QuoteReqID>(offset);
20172  }
20173 
20174  /// Unique identifier for quote request.
20175  ThisType& setQuoteReqId(QuoteReqID value)
20177  {
20179 
20180  setOrdinary(offset, value);
20181  return *this;
20182  }
20183 
20184  /// Unique identifier for quote.
20188  {
20190 
20191  return ordinary<QuoteID>(offset);
20192  }
20193 
20194  /// Unique identifier for quote.
20195  ThisType& setQuoteId(QuoteID value)
20197  {
20199 
20200  setOrdinary(offset, value);
20201  return *this;
20202  }
20203 
20204  /// Time of execution/order creation.
20208  {
20210 
20211  return ordinary<UTCTimestampNanos>(offset);
20212  }
20213 
20214  /// Time of execution/order creation.
20217  {
20219 
20220  setOrdinary(offset, value);
20221  return *this;
20222  }
20223 
20224  /// Price per share or contract. Conditionally required if the
20225  /// order type requires a price (not market orders and RLP).
20227  bool price(Price8Optional& value) const
20229  {
20231 
20232  return decimal(value, offset, NullPrice8Optional());
20233  }
20234 
20235  /// Price per share or contract. Conditionally required if the
20236  /// order type requires a price (not market orders and RLP).
20237  ThisType& setPrice(Price8Optional value)
20239  {
20241 
20242  setOrdinary(offset, value);
20243  return *this;
20244  }
20245 
20246  ThisType& setPriceToNull()
20248  {
20250 
20251  setOrdinary(offset, NullPrice8Optional());
20252  return *this;
20253  }
20254 
20255  /// Quantity ordered.
20259  {
20261 
20262  return ordinary<Quantity>(offset);
20263  }
20264 
20265  /// Quantity ordered.
20266  ThisType& setOrderQty(Quantity value)
20268  {
20270 
20271  setOrdinary(offset, value);
20272  return *this;
20273  }
20274 
20275  /// Side of order.
20279  {
20281 
20282  return enumeration<Side>(offset);
20283  }
20284 
20285  /// Side of order.
20286  ThisType& setSide(Side::Enum value)
20288  {
20290 
20291  setEnumeration<Side>(offset, value);
20292  return *this;
20293  }
20294 
20295  /// Indicates who in the contract has control over evoking
20296  /// settlement.
20300  {
20302 
20303  return enumeration<SettlType>(offset);
20304  }
20305 
20306  /// Indicates who in the contract has control over evoking
20307  /// settlement.
20310  {
20312 
20313  setEnumeration<SettlType>(offset, value);
20314  return *this;
20315  }
20316 
20317  /// Account mnemonic of the order.
20319  bool account(AccountOptional& value) const
20321  {
20323 
20324  return ordinary(value, offset, NullAccountOptional());
20325  }
20326 
20327  /// Account mnemonic of the order.
20328  ThisType& setAccount(AccountOptional value)
20330  {
20332 
20333  setOrdinary(offset, value);
20334  return *this;
20335  }
20336 
20337  ThisType& setAccountToNull()
20339  {
20341 
20342  setOrdinary(offset, NullAccountOptional());
20343  return *this;
20344  }
20345 
20346  /// Identifies the original location for routing orders.
20350  {
20353 
20354  return fixedStr<length>(offset);
20355  }
20356 
20357  /// Identifies the original location for routing orders.
20358  ThisType& setSenderLocation(StrRef value)
20360  {
20363 
20364  setFixedStr<length>(offset, value);
20365  return *this;
20366  }
20367 
20368  /// Identifies the trader who is inserting an order.
20372  {
20375 
20376  return fixedStr<length>(offset);
20377  }
20378 
20379  /// Identifies the trader who is inserting an order.
20380  ThisType& setEnteringTrader(StrRef value)
20382  {
20385 
20386  setFixedStr<length>(offset, value);
20387  return *this;
20388  }
20389 
20390  /// Identifies the trader who is executing an order.
20394  {
20397 
20398  return fixedStr<length>(offset);
20399  }
20400 
20401  /// Identifies the trader who is executing an order.
20402  ThisType& setExecutingTrader(StrRef value)
20404  {
20407 
20408  setFixedStr<length>(offset, value);
20409  return *this;
20410  }
20411 
20412  /// Interest rate of the forward trade.
20416  {
20418 
20419  return decimal<Percentage8>(offset);
20420  }
20421 
20422  /// Interest rate of the forward trade.
20423  ThisType& setFixedRate(Percentage8 value)
20425  {
20427 
20428  setOrdinary(offset, value);
20429  return *this;
20430  }
20431 
20432  /// Specifies if a simultaneous trade of the underlying is to
20433  /// be performed.Required to indicate Termo Vista and Termo
20434  /// Vista Registered.
20436  bool
20438  ExecuteUnderlyingTrade::Enum& value) const
20440  {
20442 
20443  return enumeration<ExecuteUnderlyingTrade>(value, offset, NullChar());
20444  }
20445 
20446  /// Specifies if a simultaneous trade of the underlying is to
20447  /// be performed.Required to indicate Termo Vista and Termo
20448  /// Vista Registered.
20449  ThisType&
20453  {
20455 
20456  setEnumeration<ExecuteUnderlyingTrade>(offset, value);
20457  return *this;
20458  }
20459 
20462  {
20464 
20465  setOrdinary(offset, NullChar());
20466  return *this;
20467  }
20468 
20469  /// Specifies whether a quote is public, i.e. available to the
20470  /// market, or private, i.e. available to a specified
20471  /// counterparty only.
20476  {
20477  return Boolean::TrueValue;
20478  }
20479 
20480  /// Specifies whether a quote is public, i.e. available to the
20481  /// market, or private, i.e. available to a specified
20482  /// counterparty only.
20483 
20484  /// Deadline for completing the forward deal. For Common,
20485  /// Dollar and Index contracts must be between 16 and 999. And
20486  /// maximum of 90 days for Flexible.
20490  {
20492 
20493  return ordinary<DaysToSettlement>(offset);
20494  }
20495 
20496  /// Deadline for completing the forward deal. For Common,
20497  /// Dollar and Index contracts must be between 16 and 999. And
20498  /// maximum of 90 days for Flexible.
20501  {
20503 
20504  setOrdinary(offset, value);
20505  return *this;
20506  }
20507 
20508  /// Account used for associating risk limits (when defined).
20512  {
20515 
20516  return ordinary(value, offset, NullAccountOptional(), since);
20517  }
20518 
20519  /// Account used for associating risk limits (when defined).
20521  {
20524 
20525  setOrdinary(offset, value, since);
20526  return *this;
20527  }
20528 
20530  {
20533 
20534  setOrdinary(offset, NullAccountOptional(), since);
20535  return *this;
20536  }
20537 
20538  /// Identifies the trading desk.
20540  StrRef deskId() const
20542  {
20543  return getVariableLengthField(deskIDAccess(), *this);
20544  }
20545 
20546  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
20548  StrRef memo() const
20550  {
20551  return getVariableLengthField(memoAccess(), *this);
20552  }
20553 
20554  /// Identifies the trading desk.
20555  ThisType& setDeskId(StrRef value)
20556  {
20557  setVariableLengthField(
20558  deskIDAccess(),
20559  value,
20560  *this);
20561 
20562  return *this;
20563  }
20564 
20565  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
20566  ThisType& setMemo(StrRef value)
20567  {
20568  setVariableLengthField(
20569  memoAccess(),
20570  value,
20571  *this);
20572 
20573  return *this;
20574  }
20575 
20576  /// Minimal size of message body in bytes.
20581  {
20582  return
20583  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
20584  (version >= 5)
20585  ? 109
20586  : 105;
20587  }
20588 
20589  /// Size of message body in bytes.
20594  {
20595  return
20596  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
20597  minimalBlockLength(version);
20598  }
20599 
20600  /// Minimal variable fields size (when variable-length fields are empty).
20604  static
20605  MessageSize
20608  {
20609  return
20610  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
20611  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
20612  }
20613 
20614  /// Maximal message size.
20618  static UInt64 getMaxMessageSize(UInt8)
20620  {
20621  return
20623  }
20624 
20625  /// Reset all variable-length fields if any.
20628  {
20629  setDeskIdToNull();
20630  setMemoToNull();
20631  return *this;
20632  }
20633 
20634  /// Reset all variable-length and optional fields if any.
20635  ThisType& reset()
20637  {
20638  setPriceToNull();
20639  setAccountToNull();
20640  setExecuteUnderlyingTradeToNull();
20641 
20642  if (version() >= 5)
20643  {
20644  setTradingSubAccountToNull();
20645  }
20646 
20647  resetVariableFields();
20648  return *this;
20649  }
20650 
20651  /// \return class name.
20655  static const Char* className()
20656  {
20657  return "Quote403";
20658  }
20659 
20660  /// FIX message type.
20664  static StrRef fixType()
20666  {
20667  return constructStrRef("Quote403");
20668  }
20669 
20670  /// \return a human-readable presentation.
20672  std::string toString() const;
20673 
20674  /// \return the end of the message.
20676  const void* tail() const
20678  {
20679  return
20680  toOpaquePtr(
20681  (memo().end()));
20682  }
20683 
20684  /// \return the size occupied by the message.
20688  {
20689  return
20690  SbeMessage::calculateBinarySize(tail());
20691  }
20692 
20693 private:
20694  void checkLength(
20695  EncodedLength length, SchemaVersion version) const
20696  {
20697  const EncodedLength minimalRequiredLength =
20698  minimalBlockLength(version) +
20699  MessageHeader::Size +
20700  getMinimalVariableFieldsSize(version);
20701 
20702  checkBinaryLength(
20703  *this, length, minimalRequiredLength);
20704  }
20705 
20706  /// Checks variable fields consistency.
20707  void checkVarLenFields() const
20708  {
20709  variableLengthFields().
20710  checkTail<DeskIDEncoding>().
20711  checkTail<MemoEncoding>();
20712  }
20713 
20714  void checkCompatibility() const
20715  {
20716  assert(TemplateId == templateId());
20717 
20718  checkSchema<Schema>(schemaId(), version());
20719  checkLength(bufferSize(), version());
20720  checkVarLenFields();
20721  }
20722 
20723  /// Access helper.
20724  struct deskIDAccess
20725  {
20726  DeskIDEncoding& operator()(const Quote403& obj) const
20728  {
20729  return obj.
20730  variableLengthFields().
20731  head<DeskIDEncoding>();
20732  }
20733  };
20734 
20735  /// Access helper.
20736  struct memoAccess
20737  {
20738  MemoEncoding& operator()(const Quote403& obj) const
20740  {
20741  return obj.
20742  variableLengthFields().
20743  tail<DeskIDEncoding>().
20744  head<MemoEncoding>();
20745  }
20746  };
20747 
20748  /// Reset the field.
20749  /// All the following data will be invalidated.
20750  ThisType& setDeskIdToNull()
20752  {
20753  setVariableLengthFieldToNull(deskIDAccess(), *this);
20754 
20755  return *this;
20756  }
20757 
20758  /// Reset the field.
20759  /// All the following data will be invalidated.
20760  ThisType& setMemoToNull()
20762  {
20763  setVariableLengthFieldToNull(memoAccess(), *this);
20764 
20765  return *this;
20766  }
20767 };
20768 
20769 /// The QuoteCancel message is used to cancel a previous QuoteRequest message.
20772 : SbeMessage
20773 {
20774  /// Used template schema.
20776 
20777  /// This type alias.
20779 
20780  /// Message template ID from SBE schema.
20781  enum { TemplateId = 404 };
20782 
20783  /// Initializes a blank instance.
20785 
20786  /// Initializes an instance over the given memory block.
20788  void* data,
20789  EncodedLength length,
20790  SchemaVersion version = Schema::Version)
20791  : SbeMessage(data, length, version)
20792  {
20793  checkVersion<Schema>(version);
20794  checkLength(length, version);
20795  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
20796  reset();
20797  }
20798 
20799  /// Initializes an instance over the given memory block
20800  /// With no variable-length fields initialization
20801  /// It is assumed that the user does such an initialization manually.
20803  void* data,
20804  EncodedLength length,
20805  NoFieldsInit,
20806  SchemaVersion version = Schema::Version)
20807  : SbeMessage(data, length, version)
20808  {
20809  checkVersion<Schema>(version);
20810  checkLength(length, version);
20811  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
20812  resetVariableFields();
20813  }
20814 
20815  /// Creates an instance over the given memory block.
20817  void* data,
20818  EncodedLength length,
20819  NoInit)
20820  : SbeMessage(data, length)
20821  {
20822  checkCompatibility();
20823  }
20824 
20825  /// Creates an instance over the given SBE message.
20826  explicit
20828  const SbeMessage& message)
20829  : SbeMessage(message)
20830  {
20831  assert(message.valid());
20832 
20833  checkCompatibility();
20834  }
20835 
20836  /// Creates an instance over the given memory block.
20837  /// Performs no checks.
20839  void* data,
20840  EncodedLength length,
20841  NoInit,
20842  NoCheck)
20844  : SbeMessage(data, length, NoCheck())
20845  {
20846  assert(schemaId() == Schema::Id);
20847  assert(version() >= Schema::MinimalVersion);
20848  assert(TemplateId == templateId());
20849  }
20850 
20851  /// Message type = QuoteCancel.
20856  {
20857  return MessageType::QuoteCancel;
20858  }
20859 
20860  /// Message type = QuoteCancel.
20861 
20862  /// Common header to all bidirectional business messages.
20867  {
20869 
20870  return accessOrdinary<BidirectionalBusinessHeader>(offset);
20871  }
20872 
20873  /// Common header to all bidirectional business messages.
20877  {
20879  return accessOrdinary<BidirectionalBusinessHeader>(offset);
20880  }
20881 
20882  /// Security identification as defined by exchange.
20886  {
20888 
20889  return ordinary<SecurityID>(offset);
20890  }
20891 
20892  /// Security identification as defined by exchange.
20893  ThisType& setSecurityId(SecurityID value)
20895  {
20897 
20898  setOrdinary(offset, value);
20899  return *this;
20900  }
20901 
20902  /// Identifies the class of the SecurityID (Exchange Symbol).
20907  {
20908  return SecurityIDSource::ExchangeSymbol;
20909  }
20910 
20911  /// Identifies the class of the SecurityID (Exchange Symbol).
20912 
20913  /// Market to which the symbol belongs.
20919  {
20920  return constructStrRef("BVMF");
20921  }
20922 
20923  /// Unique identifier for quote request.
20925  bool
20927  QuoteReqIDOptional& value) const
20929  {
20931 
20932  return ordinary(value, offset, NullQuoteReqIDOptional());
20933  }
20934 
20935  /// Unique identifier for quote request.
20938  {
20940 
20941  setOrdinary(offset, value);
20942  return *this;
20943  }
20944 
20947  {
20949 
20950  setOrdinary(offset, NullQuoteReqIDOptional());
20951  return *this;
20952  }
20953 
20954  /// Unique identifier for quote.
20956  bool quoteId(QuoteIDOptional& value) const
20958  {
20960 
20961  return ordinary(value, offset, NullQuoteIDOptional());
20962  }
20963 
20964  /// Unique identifier for quote.
20965  ThisType& setQuoteId(QuoteIDOptional value)
20967  {
20969 
20970  setOrdinary(offset, value);
20971  return *this;
20972  }
20973 
20974  ThisType& setQuoteIdToNull()
20976  {
20978 
20979  setOrdinary(offset, NullQuoteIDOptional());
20980  return *this;
20981  }
20982 
20983  /// Identifies the type of quote cancel.
20988  {
20989  return QuoteCancelType::CancelForQuoteId;
20990  }
20991 
20992  /// Identifies the type of quote cancel.
20993 
20994  /// Account mnemonic of the order.
20996  bool account(AccountOptional& value) const
20998  {
21000 
21001  return ordinary(value, offset, NullAccountOptional());
21002  }
21003 
21004  /// Account mnemonic of the order.
21005  ThisType& setAccount(AccountOptional value)
21007  {
21009 
21010  setOrdinary(offset, value);
21011  return *this;
21012  }
21013 
21014  ThisType& setAccountToNull()
21016  {
21018 
21019  setOrdinary(offset, NullAccountOptional());
21020  return *this;
21021  }
21022 
21023  /// Identifies the original location for routing orders.
21027  {
21030 
21031  return fixedStr<length>(offset);
21032  }
21033 
21034  /// Identifies the original location for routing orders.
21035  ThisType& setSenderLocation(StrRef value)
21037  {
21040 
21041  setFixedStr<length>(offset, value);
21042  return *this;
21043  }
21044 
21045  /// Identifies the trader who is inserting an order.
21049  {
21052 
21053  return fixedStr<length>(offset);
21054  }
21055 
21056  /// Identifies the trader who is inserting an order.
21057  ThisType& setEnteringTrader(StrRef value)
21059  {
21062 
21063  setFixedStr<length>(offset, value);
21064  return *this;
21065  }
21066 
21067  /// Identifies the trader who is executing an order.
21071  {
21074 
21075  return fixedStr<length>(offset);
21076  }
21077 
21078  /// Identifies the trader who is executing an order.
21079  ThisType& setExecutingTrader(StrRef value)
21081  {
21084 
21085  setFixedStr<length>(offset, value);
21086  return *this;
21087  }
21088 
21089  /// Specifies whether a quote is public, i.e. available to the
21090  /// market, or private, i.e. available to a specified
21091  /// counterparty only.
21096  {
21097  return Boolean::TrueValue;
21098  }
21099 
21100  /// Specifies whether a quote is public, i.e. available to the
21101  /// market, or private, i.e. available to a specified
21102  /// counterparty only.
21103 
21104  /// Identifies the trading desk.
21106  StrRef deskId() const
21108  {
21109  return getVariableLengthField(deskIDAccess(), *this);
21110  }
21111 
21112  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
21114  StrRef memo() const
21116  {
21117  return getVariableLengthField(memoAccess(), *this);
21118  }
21119 
21120  /// Identifies the trading desk.
21121  ThisType& setDeskId(StrRef value)
21122  {
21123  setVariableLengthField(
21124  deskIDAccess(),
21125  value,
21126  *this);
21127 
21128  return *this;
21129  }
21130 
21131  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
21132  ThisType& setMemo(StrRef value)
21133  {
21134  setVariableLengthField(
21135  memoAccess(),
21136  value,
21137  *this);
21138 
21139  return *this;
21140  }
21141 
21142  /// Minimal size of message body in bytes.
21145  static
21146  BlockLength
21150  {
21151  return
21152  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
21153  68;
21154  }
21155 
21156  /// Size of message body in bytes.
21161  {
21162  return
21163  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
21164  minimalBlockLength(version);
21165  }
21166 
21167  /// Minimal variable fields size (when variable-length fields are empty).
21171  static
21172  MessageSize
21175  {
21176  return
21177  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
21178  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
21179  }
21180 
21181  /// Maximal message size.
21185  static UInt64 getMaxMessageSize(UInt8)
21187  {
21188  return
21190  }
21191 
21192  /// Reset all variable-length fields if any.
21195  {
21196  setDeskIdToNull();
21197  setMemoToNull();
21198  return *this;
21199  }
21200 
21201  /// Reset all variable-length and optional fields if any.
21202  ThisType& reset()
21204  {
21205  setQuoteReqIdToNull();
21206  setQuoteIdToNull();
21207  setAccountToNull();
21208 
21209  resetVariableFields();
21210  return *this;
21211  }
21212 
21213  /// \return class name.
21217  static const Char* className()
21218  {
21219  return "QuoteCancel404";
21220  }
21221 
21222  /// FIX message type.
21226  static StrRef fixType()
21228  {
21229  return constructStrRef("QuoteCancel404");
21230  }
21231 
21232  /// \return a human-readable presentation.
21234  std::string toString() const;
21235 
21236  /// \return the end of the message.
21238  const void* tail() const
21240  {
21241  return
21242  toOpaquePtr(
21243  (memo().end()));
21244  }
21245 
21246  /// \return the size occupied by the message.
21250  {
21251  return
21252  SbeMessage::calculateBinarySize(tail());
21253  }
21254 
21255 private:
21256  void checkLength(
21257  EncodedLength length, SchemaVersion version) const
21258  {
21259  const EncodedLength minimalRequiredLength =
21260  minimalBlockLength(version) +
21261  MessageHeader::Size +
21262  getMinimalVariableFieldsSize(version);
21263 
21264  checkBinaryLength(
21265  *this, length, minimalRequiredLength);
21266  }
21267 
21268  /// Checks variable fields consistency.
21269  void checkVarLenFields() const
21270  {
21271  variableLengthFields().
21272  checkTail<DeskIDEncoding>().
21273  checkTail<MemoEncoding>();
21274  }
21275 
21276  void checkCompatibility() const
21277  {
21278  assert(TemplateId == templateId());
21279 
21280  checkSchema<Schema>(schemaId(), version());
21281  checkLength(bufferSize(), version());
21282  checkVarLenFields();
21283  }
21284 
21285  /// Access helper.
21286  struct deskIDAccess
21287  {
21289  operator()(
21290  const QuoteCancel404& obj) const
21292  {
21293  return obj.
21294  variableLengthFields().
21295  head<DeskIDEncoding>();
21296  }
21297  };
21298 
21299  /// Access helper.
21300  struct memoAccess
21301  {
21302  MemoEncoding&
21303  operator()(
21304  const QuoteCancel404& obj) const
21306  {
21307  return obj.
21308  variableLengthFields().
21309  tail<DeskIDEncoding>().
21310  head<MemoEncoding>();
21311  }
21312  };
21313 
21314  /// Reset the field.
21315  /// All the following data will be invalidated.
21316  ThisType& setDeskIdToNull()
21318  {
21319  setVariableLengthFieldToNull(deskIDAccess(), *this);
21320 
21321  return *this;
21322  }
21323 
21324  /// Reset the field.
21325  /// All the following data will be invalidated.
21326  ThisType& setMemoToNull()
21328  {
21329  setVariableLengthFieldToNull(memoAccess(), *this);
21330 
21331  return *this;
21332  }
21333 };
21334 
21335 /// The QuoteRequestReject message is used when a QuoteRequest is not accept by B3 due to missing or incorrect details to reject QuoteRequest messages for all quoting models.
21338 : SbeMessage
21339 {
21340  /// Used template schema.
21342 
21343  /// This type alias.
21345 
21346  /// Message template ID from SBE schema.
21347  enum { TemplateId = 405 };
21348 
21349  /// Repeating group dimensions.
21350  /// Entry of SidesEntry repeating group.
21353  <
21355  >
21356  {
21357  /// Base class type.
21358  typedef
21360  <
21362  >
21364 
21365  /// This type alias.
21367 
21368  /// Initializes instance of given
21369  /// version over given memory block.
21371  void* data,
21372  EncodedLength length,
21373  SchemaVersion version)
21374  : Base(data, numericCast<Base::BlockLength>(length), version)
21375  {
21376  assert(version >= Schema::MinimalVersion);
21377  assert(length >= minimalBlockLength(version));
21378  }
21379 
21380  /// Reset all variable-length fields if any.
21383  {
21384  return *this;
21385  }
21386 
21387  /// Reset all variable-length and optional fields if any.
21388  ThisType& reset()
21390  {
21391  setAccountToNull();
21392 
21393  if (version() >= 5)
21394  {
21395  setTradingSubAccountToNull();
21396  }
21397 
21398  resetVariableFields();
21399  return *this;
21400  }
21401 
21402  /// Side of order.
21406  {
21408 
21409  return enumeration<Side>(offset);
21410  }
21411 
21412  /// Side of order.
21413  ThisType& setSide(Side::Enum value)
21415  {
21417 
21418  setEnumeration<Side>(offset, value);
21419  return *this;
21420  }
21421 
21422  /// Account mnemonic of the order.
21424  bool account(AccountOptional& value) const
21426  {
21428 
21429  return ordinary(value, offset, NullAccountOptional());
21430  }
21431 
21432  /// Account mnemonic of the order.
21433  ThisType& setAccount(AccountOptional value)
21435  {
21437 
21438  setOrdinary(offset, value);
21439  return *this;
21440  }
21441 
21442  ThisType& setAccountToNull()
21444  {
21446 
21447  setOrdinary(offset, NullAccountOptional());
21448  return *this;
21449  }
21450 
21451  /// Account used for associating risk limits (when defined).
21455  {
21458 
21459  return ordinary(value, offset, NullAccountOptional(), since);
21460  }
21461 
21462  /// Account used for associating risk limits (when defined).
21464  {
21467 
21468  setOrdinary(offset, value, since);
21469  return *this;
21470  }
21471 
21473  {
21476 
21477  setOrdinary(offset, NullAccountOptional(), since);
21478  return *this;
21479  }
21480 
21481  /// \return size of entry body in bytes
21482  /// for given version of message template.
21487  {
21488  return
21489  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
21490  minimalBlockLength(version);
21491  }
21492 
21493  /// \return minimal size of entry body in bytes
21494  /// for given version of message template.
21499  {
21500  return
21501  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
21502  (version >= 5)
21503  ? 9
21504  : 5;
21505  }
21506 
21507  /// Entity class name.
21511  static const Char* className()
21512  {
21513  return "QuoteRequestReject405.SidesEntry";
21514  }
21515  };
21516 
21517  /// Repeating group containing SidesEntry entries.
21518  typedef
21521 
21522  /// Initializes a blank instance.
21524 
21525  /// Initializes an instance over the given memory block.
21527  void* data,
21528  EncodedLength length,
21529  SchemaVersion version = Schema::Version)
21530  : SbeMessage(data, length, version)
21531  {
21532  checkVersion<Schema>(version);
21533  checkLength(length, version);
21534  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
21535  reset();
21536  }
21537 
21538  /// Initializes an instance over the given memory block
21539  /// With no variable-length fields initialization
21540  /// It is assumed that the user does such an initialization manually.
21542  void* data,
21543  EncodedLength length,
21544  NoFieldsInit,
21545  SchemaVersion version = Schema::Version)
21546  : SbeMessage(data, length, version)
21547  {
21548  checkVersion<Schema>(version);
21549  checkLength(length, version);
21550  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
21551  resetVariableFields();
21552  }
21553 
21554  /// Creates an instance over the given memory block.
21556  void* data,
21557  EncodedLength length,
21558  NoInit)
21559  : SbeMessage(data, length)
21560  {
21561  checkCompatibility();
21562  }
21563 
21564  /// Creates an instance over the given SBE message.
21565  explicit
21567  const SbeMessage& message)
21568  : SbeMessage(message)
21569  {
21570  assert(message.valid());
21571 
21572  checkCompatibility();
21573  }
21574 
21575  /// Creates an instance over the given memory block.
21576  /// Performs no checks.
21578  void* data,
21579  EncodedLength length,
21580  NoInit,
21581  NoCheck)
21583  : SbeMessage(data, length, NoCheck())
21584  {
21585  assert(schemaId() == Schema::Id);
21586  assert(version() >= Schema::MinimalVersion);
21587  assert(TemplateId == templateId());
21588  }
21589 
21590  /// Message type = QuoteRequestReject.
21595  {
21596  return MessageType::QuoteRequestReject;
21597  }
21598 
21599  /// Message type = QuoteRequestReject.
21600 
21601  /// Common header to all bidirectional business messages.
21606  {
21608 
21609  return accessOrdinary<BidirectionalBusinessHeader>(offset);
21610  }
21611 
21612  /// Common header to all bidirectional business messages.
21616  {
21618  return accessOrdinary<BidirectionalBusinessHeader>(offset);
21619  }
21620 
21621  /// Reason Quote was rejected.
21625  {
21627 
21628  return ordinary(value, offset, NullRejReasonOptional());
21629  }
21630 
21631  /// Reason Quote was rejected.
21634  {
21636 
21637  setOrdinary(offset, value);
21638  return *this;
21639  }
21640 
21643  {
21645 
21646  setOrdinary(offset, NullRejReasonOptional());
21647  return *this;
21648  }
21649 
21650  /// Security identification as defined by exchange.
21654  {
21656 
21657  return ordinary<SecurityID>(offset);
21658  }
21659 
21660  /// Security identification as defined by exchange.
21661  ThisType& setSecurityId(SecurityID value)
21663  {
21665 
21666  setOrdinary(offset, value);
21667  return *this;
21668  }
21669 
21670  /// Identifies the class of the SecurityID (Exchange Symbol).
21675  {
21676  return SecurityIDSource::ExchangeSymbol;
21677  }
21678 
21679  /// Identifies the class of the SecurityID (Exchange Symbol).
21680 
21681  /// Market to which the symbol belongs.
21687  {
21688  return constructStrRef("BVMF");
21689  }
21690 
21691  /// Unique identifier for quote request.
21695  {
21697 
21698  return ordinary<QuoteReqID>(offset);
21699  }
21700 
21701  /// Unique identifier for quote request.
21702  ThisType& setQuoteReqId(QuoteReqID value)
21704  {
21706 
21707  setOrdinary(offset, value);
21708  return *this;
21709  }
21710 
21711  /// Unique identifier for quote.
21713  bool quoteId(QuoteIDOptional& value) const
21715  {
21717 
21718  return ordinary(value, offset, NullQuoteIDOptional());
21719  }
21720 
21721  /// Unique identifier for quote.
21722  ThisType& setQuoteId(QuoteIDOptional value)
21724  {
21726 
21727  setOrdinary(offset, value);
21728  return *this;
21729  }
21730 
21731  ThisType& setQuoteIdToNull()
21733  {
21735 
21736  setOrdinary(offset, NullQuoteIDOptional());
21737  return *this;
21738  }
21739 
21740  /// Contains the unique identifier for this trade, per
21741  /// instrument + trading date, as assigned by the exchange.
21743  bool tradeId(TradeIDOptional& value) const
21745  {
21747 
21748  return ordinary(value, offset, NullTradeIDOptional());
21749  }
21750 
21751  /// Contains the unique identifier for this trade, per
21752  /// instrument + trading date, as assigned by the exchange.
21753  ThisType& setTradeId(TradeIDOptional value)
21755  {
21757 
21758  setOrdinary(offset, value);
21759  return *this;
21760  }
21761 
21762  ThisType& setTradeIdToNull()
21764  {
21766 
21767  setOrdinary(offset, NullTradeIDOptional());
21768  return *this;
21769  }
21770 
21771  /// Broker identifier as assigned by B3 used to indicate the
21772  /// counterparty brokerage firm in a Forward deal.
21776  {
21778 
21779  return ordinary<Firm>(offset);
21780  }
21781 
21782  /// Broker identifier as assigned by B3 used to indicate the
21783  /// counterparty brokerage firm in a Forward deal.
21784  ThisType& setContraBroker(Firm value)
21786  {
21788 
21789  setOrdinary(offset, value);
21790  return *this;
21791  }
21792 
21793  /// Time of execution/order creation.
21797  {
21799 
21800  return ordinary<UTCTimestampNanos>(offset);
21801  }
21802 
21803  /// Time of execution/order creation.
21806  {
21808 
21809  setOrdinary(offset, value);
21810  return *this;
21811  }
21812 
21813  /// Identifies the trader who is inserting an order.
21817  {
21820 
21821  return fixedStr<length>(offset);
21822  }
21823 
21824  /// Identifies the trader who is inserting an order.
21825  ThisType& setEnteringTrader(StrRef value)
21827  {
21830 
21831  setFixedStr<length>(offset, value);
21832  return *this;
21833  }
21834 
21835  /// Indicates who in the contract has control over evoking
21836  /// settlement.
21838  bool settlType(SettlType::Enum& value) const
21840  {
21842 
21843  return enumeration<SettlType>(value, offset, NullChar());
21844  }
21845 
21846  /// Indicates who in the contract has control over evoking
21847  /// settlement.
21850  {
21852 
21853  setEnumeration<SettlType>(offset, value);
21854  return *this;
21855  }
21856 
21859  {
21861 
21862  setOrdinary(offset, NullChar());
21863  return *this;
21864  }
21865 
21866  /// Price per share or contract. Conditionally required if the
21867  /// order type requires a price (not market orders and RLP).
21869  bool price(Price8Optional& value) const
21871  {
21873 
21874  return decimal(value, offset, NullPrice8Optional());
21875  }
21876 
21877  /// Price per share or contract. Conditionally required if the
21878  /// order type requires a price (not market orders and RLP).
21879  ThisType& setPrice(Price8Optional value)
21881  {
21883 
21884  setOrdinary(offset, value);
21885  return *this;
21886  }
21887 
21888  ThisType& setPriceToNull()
21890  {
21892 
21893  setOrdinary(offset, NullPrice8Optional());
21894  return *this;
21895  }
21896 
21897  /// Quantity ordered.
21899  bool orderQty(QuantityOptional& value) const
21901  {
21903 
21904  return ordinary(value, offset, NullQuantityOptional());
21905  }
21906 
21907  /// Quantity ordered.
21910  {
21912 
21913  setOrdinary(offset, value);
21914  return *this;
21915  }
21916 
21917  ThisType& setOrderQtyToNull()
21919  {
21921 
21922  setOrdinary(offset, NullQuantityOptional());
21923  return *this;
21924  }
21925 
21926  /// Identifies the original location for routing orders.
21930  {
21933 
21934  return fixedStr<length>(offset);
21935  }
21936 
21937  /// Identifies the original location for routing orders.
21938  ThisType& setSenderLocation(StrRef value)
21940  {
21943 
21944  setFixedStr<length>(offset, value);
21945  return *this;
21946  }
21947 
21948  /// Identifies the trader who is executing an order.
21952  {
21955 
21956  return fixedStr<length>(offset);
21957  }
21958 
21959  /// Identifies the trader who is executing an order.
21960  ThisType& setExecutingTrader(StrRef value)
21962  {
21965 
21966  setFixedStr<length>(offset, value);
21967  return *this;
21968  }
21969 
21970  /// Interest rate of the forward trade.
21972  bool
21974  Percentage8Optional& value) const
21976  {
21978 
21979  return decimal(value, offset, NullPercentage8Optional());
21980  }
21981 
21982  /// Interest rate of the forward trade.
21983  ThisType&
21985  Percentage8Optional value)
21987  {
21989 
21990  setOrdinary(offset, value);
21991  return *this;
21992  }
21993 
21996  {
21998 
21999  setOrdinary(offset, NullPercentage8Optional());
22000  return *this;
22001  }
22002 
22003  /// Specifies whether a quote is public, i.e. available to the
22004  /// market, or private, i.e. available to a specified
22005  /// counterparty only.
22010  {
22011  return Boolean::TrueValue;
22012  }
22013 
22014  /// Specifies whether a quote is public, i.e. available to the
22015  /// market, or private, i.e. available to a specified
22016  /// counterparty only.
22017 
22018  /// Deadline for completing the forward deal. For Common,
22019  /// Dollar and Index contracts must be between 16 and 999. And
22020  /// maximum of 90 days for Flexible.
22022  bool
22024  DaysToSettlementOptional& value) const
22026  {
22028 
22029  return ordinary(value, offset, NullDaysToSettlementOptional());
22030  }
22031 
22032  /// Deadline for completing the forward deal. For Common,
22033  /// Dollar and Index contracts must be between 16 and 999. And
22034  /// maximum of 90 days for Flexible.
22035  ThisType&
22039  {
22041 
22042  setOrdinary(offset, value);
22043  return *this;
22044  }
22045 
22048  {
22050 
22051  setOrdinary(offset, NullDaysToSettlementOptional());
22052  return *this;
22053  }
22054 
22055  /// \return instance of Sides repeating group.
22057  Sides sides() const
22059  {
22060  return getGroup<Sides>(SidesAccess(), *this);
22061  }
22062 
22063  /// \return instance of Sides repeating group.
22067  {
22068  return getGroup<Sides>(SidesAccess(), *this);
22069  }
22070 
22071  /// Setup repeating group with the given number of entries.
22072  /// Sets all optional fields of the group entries to null.
22073  /// \return noSides(35511) repeating group.
22075  {
22076  return constructGroup<Sides>(
22077  SidesAccess(),
22078  length,
22079  *this);
22080  }
22081 
22082  /// Setup repeating group with the given number of entries.
22083  /// \return noSides(35511) repeating group.
22084  Sides
22086  Sides::Size length,
22087  NoFieldsInit)
22088  {
22089  return setupGroup<Sides>(
22090  SidesAccess(),
22091  length,
22092  *this);
22093  }
22094 
22095  /// Identifies the trading desk.
22097  StrRef deskId() const
22099  {
22100  return getVariableLengthField(deskIDAccess(), *this);
22101  }
22102 
22103  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
22105  StrRef memo() const
22107  {
22108  return getVariableLengthField(memoAccess(), *this);
22109  }
22110 
22111  /// Free ASCII format text string.
22113  StrRef text() const
22115  {
22116  return getVariableLengthField(textAccess(), *this);
22117  }
22118 
22119  /// Identifies the trading desk.
22120  ThisType& setDeskId(StrRef value)
22121  {
22122  setVariableLengthField(
22123  deskIDAccess(),
22124  value,
22125  *this);
22126 
22127  return *this;
22128  }
22129 
22130  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
22131  ThisType& setMemo(StrRef value)
22132  {
22133  setVariableLengthField(
22134  memoAccess(),
22135  value,
22136  *this);
22137 
22138  return *this;
22139  }
22140 
22141  /// Free ASCII format text string.
22142  ThisType& setText(StrRef value)
22143  {
22144  setVariableLengthField(
22145  textAccess(),
22146  value,
22147  *this);
22148 
22149  return *this;
22150  }
22151 
22152  /// Minimal size of message body in bytes.
22155  static
22156  BlockLength
22160  {
22161  return
22162  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
22163  111;
22164  }
22165 
22166  /// Size of message body in bytes.
22171  {
22172  return
22173  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
22174  minimalBlockLength(version);
22175  }
22176 
22177  /// Minimal variable fields size (when variable-length fields are empty).
22181  static
22182  MessageSize
22185  {
22186  return
22187  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
22188  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size) + static_cast<MessageSize>(TextEncoding::Size) + static_cast<MessageSize>(Sides::EmptySize);
22189  }
22190 
22191  /// Maximal message size.
22195  static UInt64 getMaxMessageSize(UInt8)
22197  {
22198  return
22200  }
22201 
22202  /// Reset all variable-length fields if any.
22205  {
22206  setSidesToNull();
22207  setDeskIdToNull();
22208  setMemoToNull();
22209  setTextToNull();
22210  return *this;
22211  }
22212 
22213  /// Reset all variable-length and optional fields if any.
22214  ThisType& reset()
22216  {
22217  setQuoteRequestRejectReasonToNull();
22218  setQuoteIdToNull();
22219  setTradeIdToNull();
22220  setSettlTypeToNull();
22221  setPriceToNull();
22222  setOrderQtyToNull();
22223  setFixedRateToNull();
22224  setDaysToSettlementToNull();
22225 
22226  resetVariableFields();
22227  return *this;
22228  }
22229 
22230  /// \return class name.
22234  static const Char* className()
22235  {
22236  return "QuoteRequestReject405";
22237  }
22238 
22239  /// FIX message type.
22243  static StrRef fixType()
22245  {
22246  return constructStrRef("QuoteRequestReject405");
22247  }
22248 
22249  /// \return a human-readable presentation.
22251  std::string toString() const;
22252 
22253  /// \return the end of the message.
22255  const void* tail() const
22257  {
22258  return
22259  toOpaquePtr(
22260  (text().end()));
22261  }
22262 
22263  /// \return the size occupied by the message.
22267  {
22268  return
22269  SbeMessage::calculateBinarySize(tail());
22270  }
22271 
22272 private:
22273  void checkLength(
22274  EncodedLength length, SchemaVersion version) const
22275  {
22276  const EncodedLength minimalRequiredLength =
22277  minimalBlockLength(version) +
22278  MessageHeader::Size +
22279  getMinimalVariableFieldsSize(version);
22280 
22281  checkBinaryLength(
22282  *this, length, minimalRequiredLength);
22283  }
22284 
22285  /// Checks variable fields consistency.
22286  void checkVarLenFields() const
22287  {
22288  groups().
22289  checkVariableLengthFields<Sides>().
22290  checkTail<DeskIDEncoding>().
22291  checkTail<MemoEncoding>().
22292  checkTail<TextEncoding>();
22293  }
22294 
22295  void checkCompatibility() const
22296  {
22297  assert(TemplateId == templateId());
22298 
22299  checkSchema<Schema>(schemaId(), version());
22300  checkLength(bufferSize(), version());
22301  checkVarLenFields();
22302  }
22303 
22304  /// Access helper.
22305  struct SidesAccess
22306  {
22307  Sides
22308  operator()(
22309  const QuoteRequestReject405& obj) const
22311  {
22312  return obj.
22313  groups().
22314  head<Sides>();
22315  }
22316  };
22317 
22318  /// Reset an instance of the repeating group.
22319  /// All the following data will be invalidated.
22320  void setSidesToNull()
22322  {
22323  resetGroup<Sides>(SidesAccess(), *this);
22324  }
22325 
22326  /// Access helper.
22327  struct deskIDAccess
22328  {
22330  operator()(
22331  const QuoteRequestReject405& obj) const
22333  {
22334  return obj.
22335  groups().
22336  variableLengthFields<Sides>().
22337  head<DeskIDEncoding>();
22338  }
22339  };
22340 
22341  /// Access helper.
22342  struct memoAccess
22343  {
22344  MemoEncoding&
22345  operator()(
22346  const QuoteRequestReject405& obj) const
22348  {
22349  return obj.
22350  groups().
22351  variableLengthFields<Sides>().
22352  tail<DeskIDEncoding>().
22353  head<MemoEncoding>();
22354  }
22355  };
22356 
22357  /// Access helper.
22358  struct textAccess
22359  {
22360  TextEncoding&
22361  operator()(
22362  const QuoteRequestReject405& obj) const
22364  {
22365  return obj.
22366  groups().
22367  variableLengthFields<Sides>().
22368  tail<DeskIDEncoding>().
22369  tail<MemoEncoding>().
22370  head<TextEncoding>();
22371  }
22372  };
22373 
22374  /// Reset the field.
22375  /// All the following data will be invalidated.
22376  ThisType& setDeskIdToNull()
22378  {
22379  setVariableLengthFieldToNull(deskIDAccess(), *this);
22380 
22381  return *this;
22382  }
22383 
22384  /// Reset the field.
22385  /// All the following data will be invalidated.
22386  ThisType& setMemoToNull()
22388  {
22389  setVariableLengthFieldToNull(memoAccess(), *this);
22390 
22391  return *this;
22392  }
22393 
22394  /// Reset the field.
22395  /// All the following data will be invalidated.
22396  ThisType& setTextToNull()
22398  {
22399  setVariableLengthFieldToNull(textAccess(), *this);
22400 
22401  return *this;
22402  }
22403 };
22404 
22405 /// PositionMaintenanceCancelRequest is a solicited cancel of PositionMaintenance message sent by client.
22408 : SbeMessage
22409 {
22410  /// Used template schema.
22412 
22413  /// This type alias.
22415 
22416  /// Message template ID from SBE schema.
22417  enum { TemplateId = 501 };
22418 
22419  /// Initializes a blank instance.
22421 
22422  /// Initializes an instance over the given memory block.
22424  void* data,
22425  EncodedLength length,
22426  SchemaVersion version = Schema::Version)
22427  : SbeMessage(data, length, version)
22428  {
22429  checkVersion<Schema>(version);
22430  checkLength(length, version);
22431  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
22432  reset();
22433  }
22434 
22435  /// Initializes an instance over the given memory block
22436  /// With no variable-length fields initialization
22437  /// It is assumed that the user does such an initialization manually.
22439  void* data,
22440  EncodedLength length,
22441  NoFieldsInit,
22442  SchemaVersion version = Schema::Version)
22443  : SbeMessage(data, length, version)
22444  {
22445  checkVersion<Schema>(version);
22446  checkLength(length, version);
22447  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
22448  resetVariableFields();
22449  }
22450 
22451  /// Creates an instance over the given memory block.
22453  void* data,
22454  EncodedLength length,
22455  NoInit)
22456  : SbeMessage(data, length)
22457  {
22458  checkCompatibility();
22459  }
22460 
22461  /// Creates an instance over the given SBE message.
22462  explicit
22464  const SbeMessage& message)
22465  : SbeMessage(message)
22466  {
22467  assert(message.valid());
22468 
22469  checkCompatibility();
22470  }
22471 
22472  /// Creates an instance over the given memory block.
22473  /// Performs no checks.
22475  void* data,
22476  EncodedLength length,
22477  NoInit,
22478  NoCheck)
22480  : SbeMessage(data, length, NoCheck())
22481  {
22482  assert(schemaId() == Schema::Id);
22483  assert(version() >= Schema::MinimalVersion);
22484  assert(TemplateId == templateId());
22485  }
22486 
22487  /// Message type = PositionMaintenanceCancelRequest.
22492  {
22493  return MessageType::PositionMaintenanceCancelRequest;
22494  }
22495 
22496  /// Message type = PositionMaintenanceCancelRequest.
22497 
22498  /// Common header to all inbound business messages.
22500  const InboundBusinessHeader&
22503  {
22505 
22506  return accessOrdinary<InboundBusinessHeader>(offset);
22507  }
22508 
22509  /// Common header to all inbound business messages.
22512  {
22514  return accessOrdinary<InboundBusinessHeader>(offset);
22515  }
22516 
22517  /// Unique identifier for the position maintenance request.
22521  {
22523 
22524  return ordinary<PosReqID>(offset);
22525  }
22526 
22527  /// Unique identifier for the position maintenance request.
22528  ThisType& setPosReqId(PosReqID value)
22530  {
22532 
22533  setOrdinary(offset, value);
22534  return *this;
22535  }
22536 
22537  /// Security identification as defined by exchange.
22541  {
22543 
22544  return ordinary<SecurityID>(offset);
22545  }
22546 
22547  /// Security identification as defined by exchange.
22548  ThisType& setSecurityId(SecurityID value)
22550  {
22552 
22553  setOrdinary(offset, value);
22554  return *this;
22555  }
22556 
22557  /// Identifies the class of the SecurityID (Exchange Symbol).
22562  {
22563  return SecurityIDSource::ExchangeSymbol;
22564  }
22565 
22566  /// Identifies the class of the SecurityID (Exchange Symbol).
22567 
22568  /// Market to which the symbol belongs.
22574  {
22575  return constructStrRef("BVMF");
22576  }
22577 
22578  /// Reference to the PosReqID (710) of a previous maintenance
22579  /// request that is being cancelled.
22583  {
22585 
22586  return ordinary(value, offset, NullPosReqIDOptional());
22587  }
22588 
22589  /// Reference to the PosReqID (710) of a previous maintenance
22590  /// request that is being cancelled.
22593  {
22595 
22596  setOrdinary(offset, value);
22597  return *this;
22598  }
22599 
22602  {
22604 
22605  setOrdinary(offset, NullPosReqIDOptional());
22606  return *this;
22607  }
22608 
22609  /// Reference to a PosMaintRptID (721) from a previous
22610  /// Position Maintenance Report that is being cancelled.
22612  bool
22614  PosMaintRptIDOptional& value) const
22616  {
22618 
22619  return ordinary(value, offset, NullPosMaintRptIDOptional());
22620  }
22621 
22622  /// Reference to a PosMaintRptID (721) from a previous
22623  /// Position Maintenance Report that is being cancelled.
22624  ThisType&
22626  PosMaintRptIDOptional value)
22628  {
22630 
22631  setOrdinary(offset, value);
22632  return *this;
22633  }
22634 
22637  {
22639 
22640  setOrdinary(offset, NullPosMaintRptIDOptional());
22641  return *this;
22642  }
22643 
22644  /// Identifies the original location for routing orders.
22648  {
22651 
22652  return fixedStr<length>(offset);
22653  }
22654 
22655  /// Identifies the original location for routing orders.
22656  ThisType& setSenderLocation(StrRef value)
22658  {
22661 
22662  setFixedStr<length>(offset, value);
22663  return *this;
22664  }
22665 
22666  /// Identifies the trader who is inserting an order.
22670  {
22673 
22674  return fixedStr<length>(offset);
22675  }
22676 
22677  /// Identifies the trader who is inserting an order.
22678  ThisType& setEnteringTrader(StrRef value)
22680  {
22683 
22684  setFixedStr<length>(offset, value);
22685  return *this;
22686  }
22687 
22688  /// Minimal size of message body in bytes.
22691  static
22692  BlockLength
22696  {
22697  return
22698  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
22699  65;
22700  }
22701 
22702  /// Size of message body in bytes.
22707  {
22708  return
22709  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
22710  minimalBlockLength(version);
22711  }
22712 
22713  /// Minimal variable fields size (when variable-length fields are empty).
22717  static
22718  MessageSize
22721  {
22722  return
22723  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
22724  0;
22725  }
22726 
22727  /// Maximal message size.
22731  static UInt64 getMaxMessageSize(UInt8)
22733  {
22734  return
22735  static_cast<UInt64>(MessageHeaderBuilder::Size) +
22736  blockLength(Schema::Version);
22737  }
22738 
22739  /// Reset all variable-length fields if any.
22742  {
22743  return *this;
22744  }
22745 
22746  /// Reset all variable-length and optional fields if any.
22747  ThisType& reset()
22749  {
22750  setOrigPosReqRefIdToNull();
22751  setPosMaintRptRefIdToNull();
22752 
22753  resetVariableFields();
22754  return *this;
22755  }
22756 
22757  /// \return class name.
22761  static const Char* className()
22762  {
22763  return "PositionMaintenanceCancelRequest501";
22764  }
22765 
22766  /// FIX message type.
22770  static StrRef fixType()
22772  {
22773  return constructStrRef(
22774  "PositionMaintenanceCancelRequest501");
22775  }
22776 
22777  /// \return a human-readable presentation.
22779  std::string toString() const;
22780 
22781  /// \return the end of the message.
22783  const void* tail() const
22785  {
22786  return
22787  toOpaquePtr(
22788  advanceByBytes(
22789  binary(),
22790  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
22791  MessageHeader::Size));
22792  }
22793 
22794  /// \return the size occupied by the message.
22798  {
22799  return
22800  SbeMessage::calculateBinarySize(tail());
22801  }
22802 
22803 private:
22804  void checkLength(
22805  EncodedLength length, SchemaVersion version) const
22806  {
22807  const EncodedLength minimalRequiredLength =
22808  minimalBlockLength(version) +
22809  MessageHeader::Size +
22810  getMinimalVariableFieldsSize(version);
22811 
22812  checkBinaryLength(
22813  *this, length, minimalRequiredLength);
22814  }
22815 
22816  void checkCompatibility() const
22817  {
22818  assert(TemplateId == templateId());
22819 
22820  checkSchema<Schema>(schemaId(), version());
22821  checkLength(bufferSize(), version());
22822  }
22823 };
22824 
22825 /// PositionMaintenanceRequest message allows the position owner (holder) to submit requests which will affect the position. Generally, the holder of the position or clearing organization is a central party but can also be a party providing investment services.
22828 : SbeMessage
22829 {
22830  /// Used template schema.
22832 
22833  /// This type alias.
22835 
22836  /// Message template ID from SBE schema.
22837  enum { TemplateId = 502 };
22838 
22839  /// Initializes a blank instance.
22841 
22842  /// Initializes an instance over the given memory block.
22844  void* data,
22845  EncodedLength length,
22846  SchemaVersion version = Schema::Version)
22847  : SbeMessage(data, length, version)
22848  {
22849  checkVersion<Schema>(version);
22850  checkLength(length, version);
22851  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
22852  reset();
22853  }
22854 
22855  /// Initializes an instance over the given memory block
22856  /// With no variable-length fields initialization
22857  /// It is assumed that the user does such an initialization manually.
22859  void* data,
22860  EncodedLength length,
22861  NoFieldsInit,
22862  SchemaVersion version = Schema::Version)
22863  : SbeMessage(data, length, version)
22864  {
22865  checkVersion<Schema>(version);
22866  checkLength(length, version);
22867  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
22868  resetVariableFields();
22869  }
22870 
22871  /// Creates an instance over the given memory block.
22873  void* data,
22874  EncodedLength length,
22875  NoInit)
22876  : SbeMessage(data, length)
22877  {
22878  checkCompatibility();
22879  }
22880 
22881  /// Creates an instance over the given SBE message.
22882  explicit
22884  const SbeMessage& message)
22885  : SbeMessage(message)
22886  {
22887  assert(message.valid());
22888 
22889  checkCompatibility();
22890  }
22891 
22892  /// Creates an instance over the given memory block.
22893  /// Performs no checks.
22895  void* data,
22896  EncodedLength length,
22897  NoInit,
22898  NoCheck)
22900  : SbeMessage(data, length, NoCheck())
22901  {
22902  assert(schemaId() == Schema::Id);
22903  assert(version() >= Schema::MinimalVersion);
22904  assert(TemplateId == templateId());
22905  }
22906 
22907  /// Message type = PositionMaintenanceRequest.
22912  {
22913  return MessageType::PositionMaintenanceRequest;
22914  }
22915 
22916  /// Message type = PositionMaintenanceRequest.
22917 
22918  /// Common header to all inbound business messages.
22920  const InboundBusinessHeader&
22923  {
22925 
22926  return accessOrdinary<InboundBusinessHeader>(offset);
22927  }
22928 
22929  /// Common header to all inbound business messages.
22932  {
22934  return accessOrdinary<InboundBusinessHeader>(offset);
22935  }
22936 
22937  /// Unique identifier for the position maintenance request.
22941  {
22943 
22944  return ordinary<PosReqID>(offset);
22945  }
22946 
22947  /// Unique identifier for the position maintenance request.
22948  ThisType& setPosReqId(PosReqID value)
22950  {
22952 
22953  setOrdinary(offset, value);
22954  return *this;
22955  }
22956 
22957  /// Security identification as defined by exchange.
22961  {
22963 
22964  return ordinary<SecurityID>(offset);
22965  }
22966 
22967  /// Security identification as defined by exchange.
22968  ThisType& setSecurityId(SecurityID value)
22970  {
22972 
22973  setOrdinary(offset, value);
22974  return *this;
22975  }
22976 
22977  /// Identifies the class of the SecurityID (Exchange Symbol).
22982  {
22983  return SecurityIDSource::ExchangeSymbol;
22984  }
22985 
22986  /// Identifies the class of the SecurityID (Exchange Symbol).
22987 
22988  /// Market to which the symbol belongs.
22994  {
22995  return constructStrRef("BVMF");
22996  }
22997 
22998  /// Used to indicate the minimum acceptable offset between the
22999  /// Strike Price and the Market Price.
23001  bool
23003  PriceOffsetOptional& value) const
23005  {
23007 
23008  return decimal(value, offset, NullPriceOffsetOptional());
23009  }
23010 
23011  /// Used to indicate the minimum acceptable offset between the
23012  /// Strike Price and the Market Price.
23013  ThisType&
23015  PriceOffsetOptional value)
23017  {
23019 
23020  setOrdinary(offset, value);
23021  return *this;
23022  }
23023 
23026  {
23028 
23029  setOrdinary(offset, NullPriceOffsetOptional());
23030  return *this;
23031  }
23032 
23033  /// Account mnemonic of the order.
23035  bool account(AccountOptional& value) const
23037  {
23039 
23040  return ordinary(value, offset, NullAccountOptional());
23041  }
23042 
23043  /// Account mnemonic of the order.
23044  ThisType& setAccount(AccountOptional value)
23046  {
23048 
23049  setOrdinary(offset, value);
23050  return *this;
23051  }
23052 
23053  ThisType& setAccountToNull()
23055  {
23057 
23058  setOrdinary(offset, NullAccountOptional());
23059  return *this;
23060  }
23061 
23062  /// Identifies the original location for routing orders.
23066  {
23069 
23070  return fixedStr<length>(offset);
23071  }
23072 
23073  /// Identifies the original location for routing orders.
23074  ThisType& setSenderLocation(StrRef value)
23076  {
23079 
23080  setFixedStr<length>(offset, value);
23081  return *this;
23082  }
23083 
23084  /// Identifies the type of position transaction.
23088  {
23090 
23091  return enumeration<PosTransType>(offset);
23092  }
23093 
23094  /// Identifies the type of position transaction.
23097  {
23099 
23100  setEnumeration<PosTransType>(offset, value);
23101  return *this;
23102  }
23103 
23104  /// The 'Clearing Business Date' referred to by this request.
23105  /// It must be set with the current date.
23109  {
23111 
23112  return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
23113  }
23114 
23115  /// The 'Clearing Business Date' referred to by this request.
23116  /// It must be set with the current date.
23119  {
23121 
23122  setOrdinary(offset, timestampToLocalMktDate(value));
23123  return *this;
23124  }
23125 
23126  /// Used to indicate when a contrary instruction for exercise
23127  /// or abandonment is being submitted: The exercise should not
23128  /// happen to an ITM position or it should happen to an ATM or
23129  /// OTM position, always using the values of tags
23130  /// 709-PosTransType and 712-PosMaintAction to determine which
23131  /// operation will take place. Should not be submitted when
23132  /// false.
23136  {
23138 
23139  return enumeration<Boolean>(offset);
23140  }
23141 
23142  /// Used to indicate when a contrary instruction for exercise
23143  /// or abandonment is being submitted: The exercise should not
23144  /// happen to an ITM position or it should happen to an ATM or
23145  /// OTM position, always using the values of tags
23146  /// 709-PosTransType and 712-PosMaintAction to determine which
23147  /// operation will take place. Should not be submitted when
23148  /// false.
23151  {
23153 
23154  setEnumeration<Boolean>(offset, value);
23155  return *this;
23156  }
23157 
23158  /// Identifies the trader who is inserting an order.
23162  {
23165 
23166  return fixedStr<length>(offset);
23167  }
23168 
23169  /// Identifies the trader who is inserting an order.
23170  ThisType& setEnteringTrader(StrRef value)
23172  {
23175 
23176  setFixedStr<length>(offset, value);
23177  return *this;
23178  }
23179 
23180  /// Used to identify the type of quantity.
23185  {
23186  return PosType::OptionExerciseQty;
23187  }
23188 
23189  /// Used to identify the type of quantity.
23190 
23191  /// Long quantity.
23195  {
23197 
23198  return ordinary<Quantity>(offset);
23199  }
23200 
23201  /// Long quantity.
23202  ThisType& setLongQty(Quantity value)
23204  {
23206 
23207  setOrdinary(offset, value);
23208  return *this;
23209  }
23210 
23211  /// Identifies the trading desk.
23213  StrRef deskId() const
23215  {
23216  return getVariableLengthField(deskIDAccess(), *this);
23217  }
23218 
23219  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
23221  StrRef memo() const
23223  {
23224  return getVariableLengthField(memoAccess(), *this);
23225  }
23226 
23227  /// Identifies the trading desk.
23228  ThisType& setDeskId(StrRef value)
23229  {
23230  setVariableLengthField(
23231  deskIDAccess(),
23232  value,
23233  *this);
23234 
23235  return *this;
23236  }
23237 
23238  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
23239  ThisType& setMemo(StrRef value)
23240  {
23241  setVariableLengthField(
23242  memoAccess(),
23243  value,
23244  *this);
23245 
23246  return *this;
23247  }
23248 
23249  /// Minimal size of message body in bytes.
23252  static
23253  BlockLength
23257  {
23258  return
23259  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
23260  73;
23261  }
23262 
23263  /// Size of message body in bytes.
23268  {
23269  return
23270  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
23271  minimalBlockLength(version);
23272  }
23273 
23274  /// Minimal variable fields size (when variable-length fields are empty).
23278  static
23279  MessageSize
23282  {
23283  return
23284  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
23285  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
23286  }
23287 
23288  /// Maximal message size.
23292  static UInt64 getMaxMessageSize(UInt8)
23294  {
23295  return
23297  }
23298 
23299  /// Reset all variable-length fields if any.
23302  {
23303  setDeskIdToNull();
23304  setMemoToNull();
23305  return *this;
23306  }
23307 
23308  /// Reset all variable-length and optional fields if any.
23309  ThisType& reset()
23311  {
23312  setThresholdAmountToNull();
23313  setAccountToNull();
23314 
23315  resetVariableFields();
23316  return *this;
23317  }
23318 
23319  /// \return class name.
23323  static const Char* className()
23324  {
23325  return "PositionMaintenanceRequest502";
23326  }
23327 
23328  /// FIX message type.
23332  static StrRef fixType()
23334  {
23335  return constructStrRef(
23336  "PositionMaintenanceRequest502");
23337  }
23338 
23339  /// \return a human-readable presentation.
23341  std::string toString() const;
23342 
23343  /// \return the end of the message.
23345  const void* tail() const
23347  {
23348  return
23349  toOpaquePtr(
23350  (memo().end()));
23351  }
23352 
23353  /// \return the size occupied by the message.
23357  {
23358  return
23359  SbeMessage::calculateBinarySize(tail());
23360  }
23361 
23362 private:
23363  void checkLength(
23364  EncodedLength length, SchemaVersion version) const
23365  {
23366  const EncodedLength minimalRequiredLength =
23367  minimalBlockLength(version) +
23368  MessageHeader::Size +
23369  getMinimalVariableFieldsSize(version);
23370 
23371  checkBinaryLength(
23372  *this, length, minimalRequiredLength);
23373  }
23374 
23375  /// Checks variable fields consistency.
23376  void checkVarLenFields() const
23377  {
23378  variableLengthFields().
23379  checkTail<DeskIDEncoding>().
23380  checkTail<MemoEncoding>();
23381  }
23382 
23383  void checkCompatibility() const
23384  {
23385  assert(TemplateId == templateId());
23386 
23387  checkSchema<Schema>(schemaId(), version());
23388  checkLength(bufferSize(), version());
23389  checkVarLenFields();
23390  }
23391 
23392  /// Access helper.
23393  struct deskIDAccess
23394  {
23396  operator()(
23397  const PositionMaintenanceRequest502& obj) const
23399  {
23400  return obj.
23401  variableLengthFields().
23402  head<DeskIDEncoding>();
23403  }
23404  };
23405 
23406  /// Access helper.
23407  struct memoAccess
23408  {
23409  MemoEncoding&
23410  operator()(
23411  const PositionMaintenanceRequest502& obj) const
23413  {
23414  return obj.
23415  variableLengthFields().
23416  tail<DeskIDEncoding>().
23417  head<MemoEncoding>();
23418  }
23419  };
23420 
23421  /// Reset the field.
23422  /// All the following data will be invalidated.
23423  ThisType& setDeskIdToNull()
23425  {
23426  setVariableLengthFieldToNull(deskIDAccess(), *this);
23427 
23428  return *this;
23429  }
23430 
23431  /// Reset the field.
23432  /// All the following data will be invalidated.
23433  ThisType& setMemoToNull()
23435  {
23436  setVariableLengthFieldToNull(memoAccess(), *this);
23437 
23438  return *this;
23439  }
23440 };
23441 
23442 /// PositionMaintenanceReport message is sent owner of a position (holder) in response to a PositionMaintenanceRequest message and is used to confirm that a request has been successfully processed or rejected.
23445 : SbeMessage
23446 {
23447  /// Used template schema.
23449 
23450  /// This type alias.
23452 
23453  /// Message template ID from SBE schema.
23454  enum { TemplateId = 503 };
23455 
23456  /// Repeating group dimensions.
23457  /// Entry of PositionsEntry repeating group.
23460  <
23462  >
23463  {
23464  /// Base class type.
23465  typedef
23467  <
23469  >
23471 
23472  /// This type alias.
23474 
23475  /// Initializes instance of given
23476  /// version over given memory block.
23478  void* data,
23479  EncodedLength length,
23480  SchemaVersion version)
23481  : Base(data, numericCast<Base::BlockLength>(length), version)
23482  {
23483  assert(version >= Schema::MinimalVersion);
23484  assert(length >= minimalBlockLength(version));
23485  }
23486 
23487  /// Reset all variable-length fields if any.
23490  {
23491  return *this;
23492  }
23493 
23494  /// Reset all variable-length and optional fields if any.
23495  ThisType& reset()
23497  {
23498  setLongQtyToNull();
23499  setShortQtyToNull();
23500 
23501  resetVariableFields();
23502  return *this;
23503  }
23504 
23505  /// Used to identify the type of quantity.
23509  {
23511 
23512  return enumeration<PosType>(offset);
23513  }
23514 
23515  /// Used to identify the type of quantity.
23516  ThisType& setPosType(PosType::Enum value)
23518  {
23520 
23521  setEnumeration<PosType>(offset, value);
23522  return *this;
23523  }
23524 
23525  /// Long Quantity.
23527  bool longQty(QuantityOptional& value) const
23529  {
23531 
23532  return ordinary(value, offset, NullQuantityOptional());
23533  }
23534 
23535  /// Long Quantity.
23536  ThisType& setLongQty(QuantityOptional value)
23538  {
23540 
23541  setOrdinary(offset, value);
23542  return *this;
23543  }
23544 
23545  ThisType& setLongQtyToNull()
23547  {
23549 
23550  setOrdinary(offset, NullQuantityOptional());
23551  return *this;
23552  }
23553 
23554  /// Short Quantity.
23556  bool shortQty(QuantityOptional& value) const
23558  {
23560 
23561  return ordinary(value, offset, NullQuantityOptional());
23562  }
23563 
23564  /// Short Quantity.
23567  {
23569 
23570  setOrdinary(offset, value);
23571  return *this;
23572  }
23573 
23574  ThisType& setShortQtyToNull()
23576  {
23578 
23579  setOrdinary(offset, NullQuantityOptional());
23580  return *this;
23581  }
23582 
23583  /// \return size of entry body in bytes
23584  /// for given version of message template.
23589  {
23590  return
23591  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
23592  minimalBlockLength(version);
23593  }
23594 
23595  /// \return minimal size of entry body in bytes
23596  /// for given version of message template.
23599  static
23600  BlockLength
23604  {
23605  return
23606  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
23607  17;
23608  }
23609 
23610  /// Entity class name.
23614  static const Char* className()
23615  {
23616  return "PositionMaintenanceReport503.PositionsEntry";
23617  }
23618  };
23619 
23620  /// Repeating group containing PositionsEntry entries.
23621  typedef
23624 
23625  /// Initializes a blank instance.
23627 
23628  /// Initializes an instance over the given memory block.
23630  void* data,
23631  EncodedLength length,
23632  SchemaVersion version = Schema::Version)
23633  : SbeMessage(data, length, version)
23634  {
23635  checkVersion<Schema>(version);
23636  checkLength(length, version);
23637  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
23638  reset();
23639  }
23640 
23641  /// Initializes an instance over the given memory block
23642  /// With no variable-length fields initialization
23643  /// It is assumed that the user does such an initialization manually.
23645  void* data,
23646  EncodedLength length,
23647  NoFieldsInit,
23648  SchemaVersion version = Schema::Version)
23649  : SbeMessage(data, length, version)
23650  {
23651  checkVersion<Schema>(version);
23652  checkLength(length, version);
23653  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
23654  resetVariableFields();
23655  }
23656 
23657  /// Creates an instance over the given memory block.
23659  void* data,
23660  EncodedLength length,
23661  NoInit)
23662  : SbeMessage(data, length)
23663  {
23664  checkCompatibility();
23665  }
23666 
23667  /// Creates an instance over the given SBE message.
23668  explicit
23670  const SbeMessage& message)
23671  : SbeMessage(message)
23672  {
23673  assert(message.valid());
23674 
23675  checkCompatibility();
23676  }
23677 
23678  /// Creates an instance over the given memory block.
23679  /// Performs no checks.
23681  void* data,
23682  EncodedLength length,
23683  NoInit,
23684  NoCheck)
23686  : SbeMessage(data, length, NoCheck())
23687  {
23688  assert(schemaId() == Schema::Id);
23689  assert(version() >= Schema::MinimalVersion);
23690  assert(TemplateId == templateId());
23691  }
23692 
23693  /// Message type = PositionMaintenanceReport.
23698  {
23699  return MessageType::PositionMaintenanceReport;
23700  }
23701 
23702  /// Message type = PositionMaintenanceReport.
23703 
23704  /// Common header to all inbound business messages.
23706  const OutboundBusinessHeader&
23709  {
23711 
23712  return accessOrdinary<OutboundBusinessHeader>(offset);
23713  }
23714 
23715  /// Common header to all inbound business messages.
23718  {
23720  return accessOrdinary<OutboundBusinessHeader>(offset);
23721  }
23722 
23723  /// Unique identifier for the position maintenance request.
23725  bool posReqId(PosReqIDOptional& value) const
23727  {
23729 
23730  return ordinary(value, offset, NullPosReqIDOptional());
23731  }
23732 
23733  /// Unique identifier for the position maintenance request.
23736  {
23738 
23739  setOrdinary(offset, value);
23740  return *this;
23741  }
23742 
23743  ThisType& setPosReqIdToNull()
23745  {
23747 
23748  setOrdinary(offset, NullPosReqIDOptional());
23749  return *this;
23750  }
23751 
23752  /// Security identification as defined by exchange.
23756  {
23758 
23759  return ordinary<SecurityID>(offset);
23760  }
23761 
23762  /// Security identification as defined by exchange.
23763  ThisType& setSecurityId(SecurityID value)
23765  {
23767 
23768  setOrdinary(offset, value);
23769  return *this;
23770  }
23771 
23772  /// Identifies the class of the SecurityID (Exchange Symbol).
23777  {
23778  return SecurityIDSource::ExchangeSymbol;
23779  }
23780 
23781  /// Identifies the class of the SecurityID (Exchange Symbol).
23782 
23783  /// Market to which the symbol belongs.
23789  {
23790  return constructStrRef("BVMF");
23791  }
23792 
23793  /// Unique identifier for this position report.
23797  {
23799 
23800  return ordinary<PosMaintRptID>(offset);
23801  }
23802 
23803  /// Unique identifier for this position report.
23806  {
23808 
23809  setOrdinary(offset, value);
23810  return *this;
23811  }
23812 
23813  /// Identifies the type of position transaction.
23817  {
23819 
23820  return enumeration<PosTransType>(offset);
23821  }
23822 
23823  /// Identifies the type of position transaction.
23826  {
23828 
23829  setEnumeration<PosTransType>(offset, value);
23830  return *this;
23831  }
23832 
23833  /// Maintenance Action to be performed.
23837  {
23839 
23840  return enumeration<PosMaintAction>(offset);
23841  }
23842 
23843  /// Maintenance Action to be performed.
23844  ThisType&
23846  PosMaintAction::Enum value)
23848  {
23850 
23851  setEnumeration<PosMaintAction>(offset, value);
23852  return *this;
23853  }
23854 
23855  /// Status of Position Maintenance Request.
23859  {
23861 
23862  return enumeration<PosMaintStatus>(offset);
23863  }
23864 
23865  /// Status of Position Maintenance Request.
23866  ThisType&
23868  PosMaintStatus::Enum value)
23870  {
23872 
23873  setEnumeration<PosMaintStatus>(offset, value);
23874  return *this;
23875  }
23876 
23877  /// The unique ID assigned to the trade entity once it is
23878  /// received or matched by the exchange or central
23879  /// counterparty.
23881  bool tradeId(TradeIDOptional& value) const
23883  {
23885 
23886  return ordinary(value, offset, NullTradeIDOptional());
23887  }
23888 
23889  /// The unique ID assigned to the trade entity once it is
23890  /// received or matched by the exchange or central
23891  /// counterparty.
23892  ThisType& setTradeId(TradeIDOptional value)
23894  {
23896 
23897  setOrdinary(offset, value);
23898  return *this;
23899  }
23900 
23901  ThisType& setTradeIdToNull()
23903  {
23905 
23906  setOrdinary(offset, NullTradeIDOptional());
23907  return *this;
23908  }
23909 
23910  /// Reference to the PosReqID (710) of a previous maintenance
23911  /// request that is being cancelled.
23915  {
23917 
23918  return ordinary(value, offset, NullPosReqIDOptional());
23919  }
23920 
23921  /// Reference to the PosReqID (710) of a previous maintenance
23922  /// request that is being cancelled.
23925  {
23927 
23928  setOrdinary(offset, value);
23929  return *this;
23930  }
23931 
23934  {
23936 
23937  setOrdinary(offset, NullPosReqIDOptional());
23938  return *this;
23939  }
23940 
23941  /// Type of account associated with an order.
23943  bool accountType(AccountType::Enum& value) const
23945  {
23947 
23948  return enumeration<AccountType>(value, offset, NullUint8EnumEncoding());
23949  }
23950 
23951  /// Type of account associated with an order.
23954  {
23956 
23957  setEnumeration<AccountType>(offset, value);
23958  return *this;
23959  }
23960 
23963  {
23965 
23966  setOrdinary(offset, NullUint8EnumEncoding());
23967  return *this;
23968  }
23969 
23970  /// The 'Clearing Business Date' referred to by this request.
23971  /// It must be set with the current date.
23975  {
23977 
23978  return localMktDateToTimestamp(ordinary<LocalMktDate>(offset));
23979  }
23980 
23981  /// The 'Clearing Business Date' referred to by this request.
23982  /// It must be set with the current date.
23985  {
23987 
23988  setOrdinary(offset, timestampToLocalMktDate(value));
23989  return *this;
23990  }
23991 
23992  /// Used to indicate the minimum acceptable offset between the
23993  /// Strike Price and the Market Price.
23995  bool
23997  PriceOffsetOptional& value) const
23999  {
24001 
24002  return decimal(value, offset, NullPriceOffsetOptional());
24003  }
24004 
24005  /// Used to indicate the minimum acceptable offset between the
24006  /// Strike Price and the Market Price.
24007  ThisType&
24009  PriceOffsetOptional value)
24011  {
24013 
24014  setOrdinary(offset, value);
24015  return *this;
24016  }
24017 
24020  {
24022 
24023  setOrdinary(offset, NullPriceOffsetOptional());
24024  return *this;
24025  }
24026 
24027  /// Time of execution/order creation.
24031  {
24033 
24034  return ordinary<UTCTimestampNanos>(offset);
24035  }
24036 
24037  /// Time of execution/order creation.
24040  {
24042 
24043  setOrdinary(offset, value);
24044  return *this;
24045  }
24046 
24047  /// Account mnemonic of the order.
24049  bool account(AccountOptional& value) const
24051  {
24053 
24054  return ordinary(value, offset, NullAccountOptional());
24055  }
24056 
24057  /// Account mnemonic of the order.
24058  ThisType& setAccount(AccountOptional value)
24060  {
24062 
24063  setOrdinary(offset, value);
24064  return *this;
24065  }
24066 
24067  ThisType& setAccountToNull()
24069  {
24071 
24072  setOrdinary(offset, NullAccountOptional());
24073  return *this;
24074  }
24075 
24076  /// Identifies the original location for routing orders.
24080  {
24083 
24084  return fixedStr<length>(offset);
24085  }
24086 
24087  /// Identifies the original location for routing orders.
24088  ThisType& setSenderLocation(StrRef value)
24090  {
24093 
24094  setFixedStr<length>(offset, value);
24095  return *this;
24096  }
24097 
24098  /// Identifies reason for rejection. Required when
24099  /// PosMaintStatus = 2.
24103  {
24105 
24106  return ordinary(value, offset, NullRejReasonOptional());
24107  }
24108 
24109  /// Identifies reason for rejection. Required when
24110  /// PosMaintStatus = 2.
24113  {
24115 
24116  setOrdinary(offset, value);
24117  return *this;
24118  }
24119 
24122  {
24124 
24125  setOrdinary(offset, NullRejReasonOptional());
24126  return *this;
24127  }
24128 
24129  /// Used to indicate when a contrary instruction for exercise
24130  /// or abandonment is being submitted :The exercise should not
24131  /// happen to an ITM position or it should happen to an ATM or
24132  /// OTM position, always using the values of tags
24133  /// 709-PosTransType and 712-PosMaintAction to determine which
24134  /// operation will take place. Should not be submitted when
24135  /// false.
24139  {
24141 
24142  return enumeration<Boolean>(offset);
24143  }
24144 
24145  /// Used to indicate when a contrary instruction for exercise
24146  /// or abandonment is being submitted :The exercise should not
24147  /// happen to an ITM position or it should happen to an ATM or
24148  /// OTM position, always using the values of tags
24149  /// 709-PosTransType and 712-PosMaintAction to determine which
24150  /// operation will take place. Should not be submitted when
24151  /// false.
24154  {
24156 
24157  setEnumeration<Boolean>(offset, value);
24158  return *this;
24159  }
24160 
24161  /// \return instance of Positions repeating group.
24165  {
24166  return getGroup<Positions>(PositionsAccess(), *this);
24167  }
24168 
24169  /// \return instance of Positions repeating group.
24173  {
24174  return getGroup<Positions>(PositionsAccess(), *this);
24175  }
24176 
24177  /// Setup repeating group with the given number of entries.
24178  /// Sets all optional fields of the group entries to null.
24179  /// \return noPositions(702) repeating group.
24181  {
24182  return constructGroup<Positions>(
24183  PositionsAccess(),
24184  length,
24185  *this);
24186  }
24187 
24188  /// Setup repeating group with the given number of entries.
24189  /// \return noPositions(702) repeating group.
24190  Positions
24192  Positions::Size length,
24193  NoFieldsInit)
24194  {
24195  return setupGroup<Positions>(
24196  PositionsAccess(),
24197  length,
24198  *this);
24199  }
24200 
24201  /// Identifies the trading desk.
24203  StrRef deskId() const
24205  {
24206  return getVariableLengthField(deskIDAccess(), *this);
24207  }
24208 
24209  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
24211  StrRef memo() const
24213  {
24214  return getVariableLengthField(memoAccess(), *this);
24215  }
24216 
24217  /// Free ASCII format text string.
24219  StrRef text() const
24221  {
24222  return getVariableLengthField(textAccess(), *this);
24223  }
24224 
24225  /// Identifies the trading desk.
24226  ThisType& setDeskId(StrRef value)
24227  {
24228  setVariableLengthField(
24229  deskIDAccess(),
24230  value,
24231  *this);
24232 
24233  return *this;
24234  }
24235 
24236  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
24237  ThisType& setMemo(StrRef value)
24238  {
24239  setVariableLengthField(
24240  memoAccess(),
24241  value,
24242  *this);
24243 
24244  return *this;
24245  }
24246 
24247  /// Free ASCII format text string.
24248  ThisType& setText(StrRef value)
24249  {
24250  setVariableLengthField(
24251  textAccess(),
24252  value,
24253  *this);
24254 
24255  return *this;
24256  }
24257 
24258  /// Minimal size of message body in bytes.
24261  static
24262  BlockLength
24266  {
24267  return
24268  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
24269  95;
24270  }
24271 
24272  /// Size of message body in bytes.
24277  {
24278  return
24279  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
24280  minimalBlockLength(version);
24281  }
24282 
24283  /// Minimal variable fields size (when variable-length fields are empty).
24287  static
24288  MessageSize
24291  {
24292  return
24293  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
24294  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size) + static_cast<MessageSize>(TextEncoding::Size) + static_cast<MessageSize>(Positions::EmptySize);
24295  }
24296 
24297  /// Maximal message size.
24301  static UInt64 getMaxMessageSize(UInt8)
24303  {
24304  return
24306  }
24307 
24308  /// Reset all variable-length fields if any.
24311  {
24312  setPositionsToNull();
24313  setDeskIdToNull();
24314  setMemoToNull();
24315  setTextToNull();
24316  return *this;
24317  }
24318 
24319  /// Reset all variable-length and optional fields if any.
24320  ThisType& reset()
24322  {
24323  setPosReqIdToNull();
24324  setTradeIdToNull();
24325  setOrigPosReqRefIdToNull();
24326  setAccountTypeToNull();
24327  setThresholdAmountToNull();
24328  setAccountToNull();
24329  setPosMaintResultToNull();
24330 
24331  resetVariableFields();
24332  return *this;
24333  }
24334 
24335  /// \return class name.
24339  static const Char* className()
24340  {
24341  return "PositionMaintenanceReport503";
24342  }
24343 
24344  /// FIX message type.
24348  static StrRef fixType()
24350  {
24351  return constructStrRef(
24352  "PositionMaintenanceReport503");
24353  }
24354 
24355  /// \return a human-readable presentation.
24357  std::string toString() const;
24358 
24359  /// \return the end of the message.
24361  const void* tail() const
24363  {
24364  return
24365  toOpaquePtr(
24366  (text().end()));
24367  }
24368 
24369  /// \return the size occupied by the message.
24373  {
24374  return
24375  SbeMessage::calculateBinarySize(tail());
24376  }
24377 
24378 private:
24379  void checkLength(
24380  EncodedLength length, SchemaVersion version) const
24381  {
24382  const EncodedLength minimalRequiredLength =
24383  minimalBlockLength(version) +
24384  MessageHeader::Size +
24385  getMinimalVariableFieldsSize(version);
24386 
24387  checkBinaryLength(
24388  *this, length, minimalRequiredLength);
24389  }
24390 
24391  /// Checks variable fields consistency.
24392  void checkVarLenFields() const
24393  {
24394  groups().
24395  checkVariableLengthFields<Positions>().
24396  checkTail<DeskIDEncoding>().
24397  checkTail<MemoEncoding>().
24398  checkTail<TextEncoding>();
24399  }
24400 
24401  void checkCompatibility() const
24402  {
24403  assert(TemplateId == templateId());
24404 
24405  checkSchema<Schema>(schemaId(), version());
24406  checkLength(bufferSize(), version());
24407  checkVarLenFields();
24408  }
24409 
24410  /// Access helper.
24411  struct PositionsAccess
24412  {
24413  Positions
24414  operator()(
24415  const PositionMaintenanceReport503& obj) const
24417  {
24418  return obj.
24419  groups().
24420  head<Positions>();
24421  }
24422  };
24423 
24424  /// Reset an instance of the repeating group.
24425  /// All the following data will be invalidated.
24426  void setPositionsToNull()
24428  {
24429  resetGroup<Positions>(PositionsAccess(), *this);
24430  }
24431 
24432  /// Access helper.
24433  struct deskIDAccess
24434  {
24436  operator()(
24437  const PositionMaintenanceReport503& obj) const
24439  {
24440  return obj.
24441  groups().
24442  variableLengthFields<Positions>().
24443  head<DeskIDEncoding>();
24444  }
24445  };
24446 
24447  /// Access helper.
24448  struct memoAccess
24449  {
24450  MemoEncoding&
24451  operator()(
24452  const PositionMaintenanceReport503& obj) const
24454  {
24455  return obj.
24456  groups().
24457  variableLengthFields<Positions>().
24458  tail<DeskIDEncoding>().
24459  head<MemoEncoding>();
24460  }
24461  };
24462 
24463  /// Access helper.
24464  struct textAccess
24465  {
24466  TextEncoding&
24467  operator()(
24468  const PositionMaintenanceReport503& obj) const
24470  {
24471  return obj.
24472  groups().
24473  variableLengthFields<Positions>().
24474  tail<DeskIDEncoding>().
24475  tail<MemoEncoding>().
24476  head<TextEncoding>();
24477  }
24478  };
24479 
24480  /// Reset the field.
24481  /// All the following data will be invalidated.
24482  ThisType& setDeskIdToNull()
24484  {
24485  setVariableLengthFieldToNull(deskIDAccess(), *this);
24486 
24487  return *this;
24488  }
24489 
24490  /// Reset the field.
24491  /// All the following data will be invalidated.
24492  ThisType& setMemoToNull()
24494  {
24495  setVariableLengthFieldToNull(memoAccess(), *this);
24496 
24497  return *this;
24498  }
24499 
24500  /// Reset the field.
24501  /// All the following data will be invalidated.
24502  ThisType& setTextToNull()
24504  {
24505  setVariableLengthFieldToNull(textAccess(), *this);
24506 
24507  return *this;
24508  }
24509 };
24510 
24511 /// AllocationInstruction message submits a request to allocate (fully or partially) a non-allocated trade to block an issuer position, preventing it to be assigned to an exercise executed by a holder during current session.
24514 : SbeMessage
24515 {
24516  /// Used template schema.
24518 
24519  /// This type alias.
24521 
24522  /// Message template ID from SBE schema.
24523  enum { TemplateId = 601 };
24524 
24525  /// Initializes a blank instance.
24527 
24528  /// Initializes an instance over the given memory block.
24530  void* data,
24531  EncodedLength length,
24532  SchemaVersion version = Schema::Version)
24533  : SbeMessage(data, length, version)
24534  {
24535  checkVersion<Schema>(version);
24536  checkLength(length, version);
24537  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
24538  reset();
24539  }
24540 
24541  /// Initializes an instance over the given memory block
24542  /// With no variable-length fields initialization
24543  /// It is assumed that the user does such an initialization manually.
24545  void* data,
24546  EncodedLength length,
24547  NoFieldsInit,
24548  SchemaVersion version = Schema::Version)
24549  : SbeMessage(data, length, version)
24550  {
24551  checkVersion<Schema>(version);
24552  checkLength(length, version);
24553  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
24554  resetVariableFields();
24555  }
24556 
24557  /// Creates an instance over the given memory block.
24559  void* data,
24560  EncodedLength length,
24561  NoInit)
24562  : SbeMessage(data, length)
24563  {
24564  checkCompatibility();
24565  }
24566 
24567  /// Creates an instance over the given SBE message.
24568  explicit
24570  const SbeMessage& message)
24571  : SbeMessage(message)
24572  {
24573  assert(message.valid());
24574 
24575  checkCompatibility();
24576  }
24577 
24578  /// Creates an instance over the given memory block.
24579  /// Performs no checks.
24581  void* data,
24582  EncodedLength length,
24583  NoInit,
24584  NoCheck)
24586  : SbeMessage(data, length, NoCheck())
24587  {
24588  assert(schemaId() == Schema::Id);
24589  assert(version() >= Schema::MinimalVersion);
24590  assert(TemplateId == templateId());
24591  }
24592 
24593  /// Message type = AllocationInstruction.
24598  {
24599  return MessageType::AllocationInstruction;
24600  }
24601 
24602  /// Message type = AllocationInstruction.
24603 
24604  /// Common header to all inbound business messages.
24606  const InboundBusinessHeader&
24609  {
24611 
24612  return accessOrdinary<InboundBusinessHeader>(offset);
24613  }
24614 
24615  /// Common header to all inbound business messages.
24618  {
24620  return accessOrdinary<InboundBusinessHeader>(offset);
24621  }
24622 
24623  /// Unique identifier for this allocation instruction message.
24627  {
24629 
24630  return ordinary<AllocID>(offset);
24631  }
24632 
24633  /// Unique identifier for this allocation instruction message.
24634  ThisType& setAllocId(AllocID value)
24636  {
24638 
24639  setOrdinary(offset, value);
24640  return *this;
24641  }
24642 
24643  /// Security identification as defined by exchange.
24647  {
24649 
24650  return ordinary<SecurityID>(offset);
24651  }
24652 
24653  /// Security identification as defined by exchange.
24654  ThisType& setSecurityId(SecurityID value)
24656  {
24658 
24659  setOrdinary(offset, value);
24660  return *this;
24661  }
24662 
24663  /// Identifies the class of the SecurityID (Exchange Symbol).
24668  {
24669  return SecurityIDSource::ExchangeSymbol;
24670  }
24671 
24672  /// Identifies the class of the SecurityID (Exchange Symbol).
24673 
24674  /// Market to which the symbol belongs.
24680  {
24681  return constructStrRef("BVMF");
24682  }
24683 
24684  /// Identifies allocation transaction type.
24688  {
24690 
24691  return enumeration<AllocTransType>(offset);
24692  }
24693 
24694  /// Identifies allocation transaction type.
24695  ThisType&
24697  AllocTransType::Enum value)
24699  {
24701 
24702  setEnumeration<AllocTransType>(offset, value);
24703  return *this;
24704  }
24705 
24706  /// Describes the specific type or purpose of an Allocation
24707  /// message.
24711  {
24713 
24714  return enumeration<AllocType>(offset);
24715  }
24716 
24717  /// Describes the specific type or purpose of an Allocation
24718  /// message.
24721  {
24723 
24724  setEnumeration<AllocType>(offset, value);
24725  return *this;
24726  }
24727 
24728  /// Indicates how the orders being booked and allocated by an
24729  /// Allocation Instruction.
24733  {
24735 
24736  return enumeration<AllocNoOrdersType>(offset);
24737  }
24738 
24739  /// Indicates how the orders being booked and allocated by an
24740  /// Allocation Instruction.
24741  ThisType&
24745  {
24747 
24748  setEnumeration<AllocNoOrdersType>(offset, value);
24749  return *this;
24750  }
24751 
24752  /// Overall/total quantity (e.g. number of shares).
24756  {
24758 
24759  return ordinary<Quantity>(offset);
24760  }
24761 
24762  /// Overall/total quantity (e.g. number of shares).
24763  ThisType& setQuantity(Quantity value)
24765  {
24767 
24768  setOrdinary(offset, value);
24769  return *this;
24770  }
24771 
24772  /// Side of order.
24775  static Side::Enum side()
24777  {
24778  return Side::Buy;
24779  }
24780 
24781  /// Side of order.
24782 
24783  /// Identifies the original location for routing orders.
24787  {
24790 
24791  return fixedStr<length>(offset);
24792  }
24793 
24794  /// Identifies the original location for routing orders.
24795  ThisType& setSenderLocation(StrRef value)
24797  {
24800 
24801  setFixedStr<length>(offset, value);
24802  return *this;
24803  }
24804 
24805  /// Identifies the trader who is inserting an order.
24809  {
24812 
24813  return fixedStr<length>(offset);
24814  }
24815 
24816  /// Identifies the trader who is inserting an order.
24817  ThisType& setEnteringTrader(StrRef value)
24819  {
24822 
24823  setFixedStr<length>(offset, value);
24824  return *this;
24825  }
24826 
24827  /// The unique ID assigned to the trade entity once it is
24828  /// received or matched by the exchange or central
24829  /// counterparty.
24833  {
24835 
24836  return ordinary<TradeID>(offset);
24837  }
24838 
24839  /// The unique ID assigned to the trade entity once it is
24840  /// received or matched by the exchange or central
24841  /// counterparty.
24842  ThisType& setTradeId(TradeID value)
24844  {
24846 
24847  setOrdinary(offset, value);
24848  return *this;
24849  }
24850 
24851  /// Indicates date of trading day (expressed in local time at
24852  /// place of trade). Sent in number of days since Unix epoch.
24854  bool tradeDate(Timestamp& value) const
24856  {
24857  typedef LocalMktDateOptional FieldValue;
24858 
24860 
24861  FieldValue fieldValue;
24862 
24863  if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
24864  {
24865  value = localMktDateToTimestamp(fieldValue);
24866  return true;
24867  }
24868  return false;
24869  }
24870 
24871  /// Indicates date of trading day (expressed in local time at
24872  /// place of trade). Sent in number of days since Unix epoch.
24873  ThisType& setTradeDate(Timestamp value)
24875  {
24877 
24878  setOrdinary(offset, timestampToLocalMktDate(value));
24879  return *this;
24880  }
24881 
24884  {
24886 
24887  setOrdinary(offset, NullLocalMktDateOptional());
24888  return *this;
24889  }
24890 
24891  /// Unique identifier for a specific NoAllocs (78) repeating
24892  /// group instance (e.g. for an AllocAccount).
24896  {
24898 
24899  return ordinary<AllocID>(offset);
24900  }
24901 
24902  /// Unique identifier for a specific NoAllocs (78) repeating
24903  /// group instance (e.g. for an AllocAccount).
24906  {
24908 
24909  setOrdinary(offset, value);
24910  return *this;
24911  }
24912 
24913  /// Sub-account mnemonic.
24917  {
24919 
24920  return ordinary<Account>(offset);
24921  }
24922 
24923  /// Sub-account mnemonic.
24924  ThisType& setAllocAccount(Account value)
24926  {
24928 
24929  setOrdinary(offset, value);
24930  return *this;
24931  }
24932 
24933  /// Quantity allocated to specific sub-account.
24937  {
24939 
24940  return ordinary<Quantity>(offset);
24941  }
24942 
24943  /// Quantity allocated to specific sub-account.
24944  ThisType& setAllocQty(Quantity value)
24946  {
24948 
24949  setOrdinary(offset, value);
24950  return *this;
24951  }
24952 
24953  /// Identifies the trading desk.
24955  StrRef deskId() const
24957  {
24958  return getVariableLengthField(deskIDAccess(), *this);
24959  }
24960 
24961  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
24963  StrRef memo() const
24965  {
24966  return getVariableLengthField(memoAccess(), *this);
24967  }
24968 
24969  /// Identifies the trading desk.
24970  ThisType& setDeskId(StrRef value)
24971  {
24972  setVariableLengthField(
24973  deskIDAccess(),
24974  value,
24975  *this);
24976 
24977  return *this;
24978  }
24979 
24980  /// Free ASCII format text field. This field may be used to convey client's relevant info. It's always echoed in the reports.
24981  ThisType& setMemo(StrRef value)
24982  {
24983  setVariableLengthField(
24984  memoAccess(),
24985  value,
24986  *this);
24987 
24988  return *this;
24989  }
24990 
24991  /// Minimal size of message body in bytes.
24994  static
24995  BlockLength
24999  {
25000  return
25001  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
25002  86;
25003  }
25004 
25005  /// Size of message body in bytes.
25010  {
25011  return
25012  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
25013  minimalBlockLength(version);
25014  }
25015 
25016  /// Minimal variable fields size (when variable-length fields are empty).
25020  static
25021  MessageSize
25024  {
25025  return
25026  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
25027  static_cast<MessageSize>(DeskIDEncoding::Size) + static_cast<MessageSize>(MemoEncoding::Size);
25028  }
25029 
25030  /// Maximal message size.
25034  static UInt64 getMaxMessageSize(UInt8)
25036  {
25037  return
25039  }
25040 
25041  /// Reset all variable-length fields if any.
25044  {
25045  setDeskIdToNull();
25046  setMemoToNull();
25047  return *this;
25048  }
25049 
25050  /// Reset all variable-length and optional fields if any.
25051  ThisType& reset()
25053  {
25054  setTradeDateToNull();
25055 
25056  resetVariableFields();
25057  return *this;
25058  }
25059 
25060  /// \return class name.
25064  static const Char* className()
25065  {
25066  return "AllocationInstruction601";
25067  }
25068 
25069  /// FIX message type.
25073  static StrRef fixType()
25075  {
25076  return constructStrRef(
25077  "AllocationInstruction601");
25078  }
25079 
25080  /// \return a human-readable presentation.
25082  std::string toString() const;
25083 
25084  /// \return the end of the message.
25086  const void* tail() const
25088  {
25089  return
25090  toOpaquePtr(
25091  (memo().end()));
25092  }
25093 
25094  /// \return the size occupied by the message.
25098  {
25099  return
25100  SbeMessage::calculateBinarySize(tail());
25101  }
25102 
25103 private:
25104  void checkLength(
25105  EncodedLength length, SchemaVersion version) const
25106  {
25107  const EncodedLength minimalRequiredLength =
25108  minimalBlockLength(version) +
25109  MessageHeader::Size +
25110  getMinimalVariableFieldsSize(version);
25111 
25112  checkBinaryLength(
25113  *this, length, minimalRequiredLength);
25114  }
25115 
25116  /// Checks variable fields consistency.
25117  void checkVarLenFields() const
25118  {
25119  variableLengthFields().
25120  checkTail<DeskIDEncoding>().
25121  checkTail<MemoEncoding>();
25122  }
25123 
25124  void checkCompatibility() const
25125  {
25126  assert(TemplateId == templateId());
25127 
25128  checkSchema<Schema>(schemaId(), version());
25129  checkLength(bufferSize(), version());
25130  checkVarLenFields();
25131  }
25132 
25133  /// Access helper.
25134  struct deskIDAccess
25135  {
25137  operator()(
25138  const AllocationInstruction601& obj) const
25140  {
25141  return obj.
25142  variableLengthFields().
25143  head<DeskIDEncoding>();
25144  }
25145  };
25146 
25147  /// Access helper.
25148  struct memoAccess
25149  {
25150  MemoEncoding&
25151  operator()(
25152  const AllocationInstruction601& obj) const
25154  {
25155  return obj.
25156  variableLengthFields().
25157  tail<DeskIDEncoding>().
25158  head<MemoEncoding>();
25159  }
25160  };
25161 
25162  /// Reset the field.
25163  /// All the following data will be invalidated.
25164  ThisType& setDeskIdToNull()
25166  {
25167  setVariableLengthFieldToNull(deskIDAccess(), *this);
25168 
25169  return *this;
25170  }
25171 
25172  /// Reset the field.
25173  /// All the following data will be invalidated.
25174  ThisType& setMemoToNull()
25176  {
25177  setVariableLengthFieldToNull(memoAccess(), *this);
25178 
25179  return *this;
25180  }
25181 };
25182 
25183 /// AllocationReport message is as response of AllocationInstruction message.
25186 : SbeMessage
25187 {
25188  /// Used template schema.
25190 
25191  /// This type alias.
25193 
25194  /// Message template ID from SBE schema.
25195  enum { TemplateId = 602 };
25196 
25197  /// Initializes a blank instance.
25199 
25200  /// Initializes an instance over the given memory block.
25202  void* data,
25203  EncodedLength length,
25204  SchemaVersion version = Schema::Version)
25205  : SbeMessage(data, length, version)
25206  {
25207  checkVersion<Schema>(version);
25208  checkLength(length, version);
25209  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
25210  reset();
25211  }
25212 
25213  /// Initializes an instance over the given memory block
25214  /// With no variable-length fields initialization
25215  /// It is assumed that the user does such an initialization manually.
25217  void* data,
25218  EncodedLength length,
25219  NoFieldsInit,
25220  SchemaVersion version = Schema::Version)
25221  : SbeMessage(data, length, version)
25222  {
25223  checkVersion<Schema>(version);
25224  checkLength(length, version);
25225  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
25226  resetVariableFields();
25227  }
25228 
25229  /// Creates an instance over the given memory block.
25231  void* data,
25232  EncodedLength length,
25233  NoInit)
25234  : SbeMessage(data, length)
25235  {
25236  checkCompatibility();
25237  }
25238 
25239  /// Creates an instance over the given SBE message.
25240  explicit
25242  const SbeMessage& message)
25243  : SbeMessage(message)
25244  {
25245  assert(message.valid());
25246 
25247  checkCompatibility();
25248  }
25249 
25250  /// Creates an instance over the given memory block.
25251  /// Performs no checks.
25253  void* data,
25254  EncodedLength length,
25255  NoInit,
25256  NoCheck)
25258  : SbeMessage(data, length, NoCheck())
25259  {
25260  assert(schemaId() == Schema::Id);
25261  assert(version() >= Schema::MinimalVersion);
25262  assert(TemplateId == templateId());
25263  }
25264 
25265  /// Message type = AllocationReport.
25270  {
25271  return MessageType::AllocationReport;
25272  }
25273 
25274  /// Message type = AllocationReport.
25275 
25276  /// Common header to all inbound business messages.
25278  const OutboundBusinessHeader&
25281  {
25283 
25284  return accessOrdinary<OutboundBusinessHeader>(offset);
25285  }
25286 
25287  /// Common header to all inbound business messages.
25290  {
25292  return accessOrdinary<OutboundBusinessHeader>(offset);
25293  }
25294 
25295  /// Unique identifier for this allocation instruction message.
25299  {
25301 
25302  return ordinary<AllocID>(offset);
25303  }
25304 
25305  /// Unique identifier for this allocation instruction message.
25306  ThisType& setAllocId(AllocID value)
25308  {
25310 
25311  setOrdinary(offset, value);
25312  return *this;
25313  }
25314 
25315  /// Security identification as defined by exchange.
25319  {
25321 
25322  return ordinary<SecurityID>(offset);
25323  }
25324 
25325  /// Security identification as defined by exchange.
25326  ThisType& setSecurityId(SecurityID value)
25328  {
25330 
25331  setOrdinary(offset, value);
25332  return *this;
25333  }
25334 
25335  /// Identifies the class of the SecurityID (Exchange Symbol).
25340  {
25341  return SecurityIDSource::ExchangeSymbol;
25342  }
25343 
25344  /// Identifies the class of the SecurityID (Exchange Symbol).
25345 
25346  /// Market to which the symbol belongs.
25352  {
25353  return constructStrRef("BVMF");
25354  }
25355 
25356  /// Unique identifier for this message.
25360  {
25362 
25363  return ordinary<AllocReportID>(offset);
25364  }
25365 
25366  /// Unique identifier for this message.
25369  {
25371 
25372  setOrdinary(offset, value);
25373  return *this;
25374  }
25375 
25376  /// Identifies allocation transaction type.
25380  {
25382 
25383  return enumeration<AllocTransType>(offset);
25384  }
25385 
25386  /// Identifies allocation transaction type.
25387  ThisType&
25389  AllocTransType::Enum value)
25391  {
25393 
25394  setEnumeration<AllocTransType>(offset, value);
25395  return *this;
25396  }
25397 
25398  /// Describes the specific type or purpose of an Allocation
25399  /// Report message.
25403  {
25405 
25406  return enumeration<AllocReportType>(offset);
25407  }
25408 
25409  /// Describes the specific type or purpose of an Allocation
25410  /// Report message.
25411  ThisType&
25413  AllocReportType::Enum value)
25415  {
25417 
25418  setEnumeration<AllocReportType>(offset, value);
25419  return *this;
25420  }
25421 
25422  /// Indicates how the orders being booked and allocated by an
25423  /// Allocation Instruction.
25427  {
25429 
25430  return enumeration<AllocNoOrdersType>(offset);
25431  }
25432 
25433  /// Indicates how the orders being booked and allocated by an
25434  /// Allocation Instruction.
25435  ThisType&
25439  {
25441 
25442  setEnumeration<AllocNoOrdersType>(offset, value);
25443  return *this;
25444  }
25445 
25446  /// Identifies reason for rejection.
25448  bool allocRejCode(RejReasonOptional& value) const
25450  {
25452 
25453  return ordinary(value, offset, NullRejReasonOptional());
25454  }
25455 
25456  /// Identifies reason for rejection.
25459  {
25461 
25462  setOrdinary(offset, value);
25463  return *this;
25464  }
25465 
25468  {
25470 
25471  setOrdinary(offset, NullRejReasonOptional());
25472  return *this;
25473  }
25474 
25475  /// Overall/total quantity (e.g. number of shares).
25479  {
25481 
25482  return ordinary<Quantity>(offset);
25483  }
25484 
25485  /// Overall/total quantity (e.g. number of shares).
25486  ThisType& setQuantity(Quantity value)
25488  {
25490 
25491  setOrdinary(offset, value);
25492  return *this;
25493  }
25494 
25495  /// Identifies status of allocation.
25499  {
25501 
25502  return enumeration<AllocStatus>(offset);
25503  }
25504 
25505  /// Identifies status of allocation.
25508  {
25510 
25511  setEnumeration<AllocStatus>(offset, value);
25512  return *this;
25513  }
25514 
25515  /// Indicates date of trading day (expressed in local time at
25516  /// place of trade). Sent in number of days since Unix epoch.
25518  bool tradeDate(Timestamp& value) const
25520  {
25521  typedef LocalMktDateOptional FieldValue;
25522 
25524 
25525  FieldValue fieldValue;
25526 
25527  if (ordinary(fieldValue, offset, NullLocalMktDateOptional()))
25528  {
25529  value = localMktDateToTimestamp(fieldValue);
25530  return true;
25531  }
25532  return false;
25533  }
25534 
25535  /// Indicates date of trading day (expressed in local time at
25536  /// place of trade). Sent in number of days since Unix epoch.
25537  ThisType& setTradeDate(Timestamp value)
25539  {
25541 
25542  setOrdinary(offset, timestampToLocalMktDate(value));
25543  return *this;
25544  }
25545 
25548  {
25550 
25551  setOrdinary(offset, NullLocalMktDateOptional());
25552  return *this;
25553  }
25554 
25555  /// Time of execution/order creation.
25559  {
25561 
25562  return ordinary<UTCTimestampNanos>(offset);
25563  }
25564 
25565  /// Time of execution/order creation.
25568  {
25570 
25571  setOrdinary(offset, value);
25572  return *this;
25573  }
25574 
25575  /// Side of order.
25579  {
25581 
25582  return enumeration<Side>(offset);
25583  }
25584 
25585  /// Side of order.
25586  ThisType& setSide(Side::Enum value)
25588  {
25590 
25591  setEnumeration<Side>(offset, value);
25592  return *this;
25593  }
25594 
25595  /// Identifies the original location for routing orders.
25599  {
25602 
25603  return fixedStr<length>(offset);
25604  }
25605 
25606  /// Identifies the original location for routing orders.
25607  ThisType& setSenderLocation(StrRef value)
25609  {
25612 
25613  setFixedStr<length>(offset, value);
25614  return *this;
25615  }
25616 
25617  /// Identifies the trader who is inserting an order.
25621  {
25624 
25625  return fixedStr<length>(offset);
25626  }
25627 
25628  /// Identifies the trader who is inserting an order.
25629  ThisType& setEnteringTrader(StrRef value)
25631  {
25634 
25635  setFixedStr<length>(offset, value);
25636  return *this;
25637  }
25638 
25639  /// Minimal size of message body in bytes.
25642  static
25643  BlockLength
25647  {
25648  return
25649  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
25650  84;
25651  }
25652 
25653  /// Size of message body in bytes.
25658  {
25659  return
25660  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
25661  minimalBlockLength(version);
25662  }
25663 
25664  /// Minimal variable fields size (when variable-length fields are empty).
25668  static
25669  MessageSize
25672  {
25673  return
25674  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
25675  0;
25676  }
25677 
25678  /// Maximal message size.
25682  static UInt64 getMaxMessageSize(UInt8)
25684  {
25685  return
25686  static_cast<UInt64>(MessageHeaderBuilder::Size) +
25687  blockLength(Schema::Version);
25688  }
25689 
25690  /// Reset all variable-length fields if any.
25693  {
25694  return *this;
25695  }
25696 
25697  /// Reset all variable-length and optional fields if any.
25698  ThisType& reset()
25700  {
25701  setAllocRejCodeToNull();
25702  setTradeDateToNull();
25703 
25704  resetVariableFields();
25705  return *this;
25706  }
25707 
25708  /// \return class name.
25712  static const Char* className()
25713  {
25714  return "AllocationReport602";
25715  }
25716 
25717  /// FIX message type.
25721  static StrRef fixType()
25723  {
25724  return constructStrRef("AllocationReport602");
25725  }
25726 
25727  /// \return a human-readable presentation.
25729  std::string toString() const;
25730 
25731  /// \return the end of the message.
25733  const void* tail() const
25735  {
25736  return
25737  toOpaquePtr(
25738  advanceByBytes(
25739  binary(),
25740  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
25741  MessageHeader::Size));
25742  }
25743 
25744  /// \return the size occupied by the message.
25748  {
25749  return
25750  SbeMessage::calculateBinarySize(tail());
25751  }
25752 
25753 private:
25754  void checkLength(
25755  EncodedLength length, SchemaVersion version) const
25756  {
25757  const EncodedLength minimalRequiredLength =
25758  minimalBlockLength(version) +
25759  MessageHeader::Size +
25760  getMinimalVariableFieldsSize(version);
25761 
25762  checkBinaryLength(
25763  *this, length, minimalRequiredLength);
25764  }
25765 
25766  void checkCompatibility() const
25767  {
25768  assert(TemplateId == templateId());
25769 
25770  checkSchema<Schema>(schemaId(), version());
25771  checkLength(bufferSize(), version());
25772  }
25773 };
25774 
25775 /// OrderMassActionRequest is sent by the client system to cancel working orders that belongs to a defined criteria as per client definition.
25778 : SbeMessage
25779 {
25780  /// Used template schema.
25782 
25783  /// This type alias.
25785 
25786  /// Message template ID from SBE schema.
25787  enum { TemplateId = 701 };
25788 
25789  /// Initializes a blank instance.
25791 
25792  /// Initializes an instance over the given memory block.
25794  void* data,
25795  EncodedLength length,
25796  SchemaVersion version = Schema::Version)
25797  : SbeMessage(data, length, version)
25798  {
25799  checkVersion<Schema>(version);
25800  checkLength(length, version);
25801  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
25802  reset();
25803  }
25804 
25805  /// Initializes an instance over the given memory block
25806  /// With no variable-length fields initialization
25807  /// It is assumed that the user does such an initialization manually.
25809  void* data,
25810  EncodedLength length,
25811  NoFieldsInit,
25812  SchemaVersion version = Schema::Version)
25813  : SbeMessage(data, length, version)
25814  {
25815  checkVersion<Schema>(version);
25816  checkLength(length, version);
25817  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
25818  resetVariableFields();
25819  }
25820 
25821  /// Creates an instance over the given memory block.
25823  void* data,
25824  EncodedLength length,
25825  NoInit)
25826  : SbeMessage(data, length)
25827  {
25828  checkCompatibility();
25829  }
25830 
25831  /// Creates an instance over the given SBE message.
25832  explicit
25834  const SbeMessage& message)
25835  : SbeMessage(message)
25836  {
25837  assert(message.valid());
25838 
25839  checkCompatibility();
25840  }
25841 
25842  /// Creates an instance over the given memory block.
25843  /// Performs no checks.
25845  void* data,
25846  EncodedLength length,
25847  NoInit,
25848  NoCheck)
25850  : SbeMessage(data, length, NoCheck())
25851  {
25852  assert(schemaId() == Schema::Id);
25853  assert(version() >= Schema::MinimalVersion);
25854  assert(TemplateId == templateId());
25855  }
25856 
25857  /// Message type = OrderMassActionRequest.
25862  {
25863  return MessageType::OrderMassActionRequest;
25864  }
25865 
25866  /// Message type = OrderMassActionRequest.
25867 
25868  /// Common header to all inbound business messages.
25870  const InboundBusinessHeader&
25873  {
25875 
25876  return accessOrdinary<InboundBusinessHeader>(offset);
25877  }
25878 
25879  /// Common header to all inbound business messages.
25882  {
25884  return accessOrdinary<InboundBusinessHeader>(offset);
25885  }
25886 
25887  /// Specifies the type of action requested.
25891  {
25893 
25894  return enumeration<MassActionType>(offset);
25895  }
25896 
25897  /// Specifies the type of action requested.
25898  ThisType&
25900  MassActionType::Enum value)
25902  {
25904 
25905  setEnumeration<MassActionType>(offset, value);
25906  return *this;
25907  }
25908 
25909  /// Specifies the scope of the action.
25911  bool
25913  MassActionScope::Enum& value) const
25915  {
25917 
25918  return enumeration<MassActionScope>(value, offset, NullUint8EnumEncoding());
25919  }
25920 
25921  /// Specifies the scope of the action.
25922  ThisType&
25924  MassActionScope::Enum value)
25926  {
25928 
25929  setEnumeration<MassActionScope>(offset, value);
25930  return *this;
25931  }
25932 
25935  {
25937 
25938  setOrdinary(offset, NullUint8EnumEncoding());
25939  return *this;
25940  }
25941 
25942  /// Unique identifier of the order as assigned by the market
25943  /// participant.
25947  {
25949 
25950  return ordinary<ClOrdID>(offset);
25951  }
25952 
25953  /// Unique identifier of the order as assigned by the market
25954  /// participant.
25955  ThisType& setClOrdId(ClOrdID value)
25957  {
25959 
25960  setOrdinary(offset, value);
25961  return *this;
25962  }
25963 
25964  /// Used to communicate event type which triggers the Order
25965  /// Mass Action Request.
25967  bool
25971  {
25973 
25974  return enumeration<ExecRestatementReasonValidForMassCancel>(value, offset, NullUint8EnumEncoding());
25975  }
25976 
25977  /// Used to communicate event type which triggers the Order
25978  /// Mass Action Request.
25979  ThisType&
25983  {
25985 
25986  setEnumeration<ExecRestatementReasonValidForMassCancel>(offset, value);
25987  return *this;
25988  }
25989 
25992  {
25994 
25995  setOrdinary(offset, NullUint8EnumEncoding());
25996  return *this;
25997  }
25998 
25999  /// Identifies the order tag identification.
26001  bool ordTagId(OrdTagID& value) const
26003  {
26005 
26006  return ordinary(value, offset, NullOrdTagID());
26007  }
26008 
26009  /// Identifies the order tag identification.
26010  ThisType& setOrdTagId(OrdTagID value)
26012  {
26014 
26015  setOrdinary(offset, value);
26016  return *this;
26017  }
26018 
26019  ThisType& setOrdTagIdToNull()
26021  {
26023 
26024  setOrdinary(offset, NullOrdTagID());
26025  return *this;
26026  }
26027 
26028  /// Side of order.
26030  bool side(Side::Enum& value) const
26032  {
26034 
26035  return enumeration<Side>(value, offset, NullChar());
26036  }
26037 
26038  /// Side of order.
26039  ThisType& setSide(Side::Enum value)
26041  {
26043 
26044  setEnumeration<Side>(offset, value);
26045  return *this;
26046  }
26047 
26048  ThisType& setSideToNull()
26050  {
26052 
26053  setOrdinary(offset, NullChar());
26054  return *this;
26055  }
26056 
26057  /// Asset associated with the security, such as DOL, BGI, OZ1,
26058  /// WDL, CNI, etc.
26060  bool asset(StrRef& value) const
26062  {
26065 
26066  return fixedStr<length>(value, offset);
26067  }
26068 
26069  /// Asset associated with the security, such as DOL, BGI, OZ1,
26070  /// WDL, CNI, etc.
26071  ThisType& setAsset(StrRef value)
26073  {
26076 
26077  setFixedStr<length>(offset, value);
26078  return *this;
26079  }
26080 
26081  ThisType& setAssetToNull()
26083  {
26086 
26087  setFixedStr<length>(offset, StrRef());
26088  return *this;
26089  }
26090 
26091  /// Security identification as defined by exchange.
26093  bool
26095  SecurityIDOptional& value) const
26097  {
26099 
26100  return ordinary(value, offset, NullSecurityIDOptional());
26101  }
26102 
26103  /// Security identification as defined by exchange.
26106  {
26108 
26109  setOrdinary(offset, value);
26110  return *this;
26111  }
26112 
26115  {
26117 
26118  setOrdinary(offset, NullSecurityIDOptional());
26119  return *this;
26120  }
26121 
26122  /// Identifies the class of the SecurityID (Exchange Symbol).
26127  {
26128  return SecurityIDSource::ExchangeSymbol;
26129  }
26130 
26131  /// Identifies the class of the SecurityID (Exchange Symbol).
26132 
26133  /// Market to which the symbol belongs.
26139  {
26140  return constructStrRef("BVMF");
26141  }
26142 
26143  /// Unique identifier of investor for mass cancel on behalf
26144  /// purposes.
26146  bool investorId(InvestorID& value) const
26148  {
26150 
26151  return ordinary(value, offset, NullInvestorID());
26152  }
26153 
26154  /// Unique identifier of investor for mass cancel on behalf
26155  /// purposes.
26156  ThisType& setInvestorId(InvestorID value)
26158  {
26160 
26161  setOrdinary(offset, value);
26162  return *this;
26163  }
26164 
26167  {
26169 
26170  setOrdinary(offset, NullInvestorID());
26171  return *this;
26172  }
26173 
26174  /// Minimal size of message body in bytes.
26177  static
26178  BlockLength
26182  {
26183  return
26184  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
26185  54;
26186  }
26187 
26188  /// Size of message body in bytes.
26191  static
26192  BlockLength
26196  {
26197  return
26198  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
26199  minimalBlockLength(version);
26200  }
26201 
26202  /// Minimal variable fields size (when variable-length fields are empty).
26206  static
26207  MessageSize
26210  {
26211  return
26212  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
26213  0;
26214  }
26215 
26216  /// Maximal message size.
26220  static UInt64 getMaxMessageSize(UInt8)
26222  {
26223  return
26224  static_cast<UInt64>(MessageHeaderBuilder::Size) +
26225  blockLength(Schema::Version);
26226  }
26227 
26228  /// Reset all variable-length fields if any.
26231  {
26232  return *this;
26233  }
26234 
26235  /// Reset all variable-length and optional fields if any.
26236  ThisType& reset()
26238  {
26239  setMassActionScopeToNull();
26240  setExecRestatementReasonToNull();
26241  setOrdTagIdToNull();
26242  setSideToNull();
26243  setAssetToNull();
26244  setSecurityIdToNull();
26245  setInvestorIdToNull();
26246 
26247  resetVariableFields();
26248  return *this;
26249  }
26250 
26251  /// \return class name.
26255  static const Char* className()
26256  {
26257  return "OrderMassActionRequest701";
26258  }
26259 
26260  /// FIX message type.
26264  static StrRef fixType()
26266  {
26267  return constructStrRef(
26268  "OrderMassActionRequest701");
26269  }
26270 
26271  /// \return a human-readable presentation.
26273  std::string toString() const;
26274 
26275  /// \return the end of the message.
26277  const void* tail() const
26279  {
26280  return
26281  toOpaquePtr(
26282  advanceByBytes(
26283  binary(),
26284  static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
26285  MessageHeader::Size));
26286  }
26287 
26288  /// \return the size occupied by the message.
26292  {
26293  return
26294  SbeMessage::calculateBinarySize(tail());
26295  }
26296 
26297 private:
26298  void checkLength(
26299  EncodedLength length, SchemaVersion version) const
26300  {
26301  const EncodedLength minimalRequiredLength =
26302  minimalBlockLength(version) +
26303  MessageHeader::Size +
26304  getMinimalVariableFieldsSize(version);
26305 
26306  checkBinaryLength(
26307  *this, length, minimalRequiredLength);
26308  }
26309 
26310  void checkCompatibility() const
26311  {
26312  assert(TemplateId == templateId());
26313 
26314  checkSchema<Schema>(schemaId(), version());
26315  checkLength(bufferSize(), version());
26316  }
26317 };
26318 
26319 /// OrderMassActionReport message is used to acknowledge an OrderMassActionRequest message.
26322 : SbeMessage
26323 {
26324  /// Used template schema.
26326 
26327  /// This type alias.
26329 
26330  /// Message template ID from SBE schema.
26331  enum { TemplateId = 702 };
26332 
26333  /// Initializes a blank instance.
26335 
26336  /// Initializes an instance over the given memory block.
26338  void* data,
26339  EncodedLength length,
26340  SchemaVersion version = Schema::Version)
26341  : SbeMessage(data, length, version)
26342  {
26343  checkVersion<Schema>(version);
26344  checkLength(length, version);
26345  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
26346  reset();
26347  }
26348 
26349  /// Initializes an instance over the given memory block
26350  /// With no variable-length fields initialization
26351  /// It is assumed that the user does such an initialization manually.
26353  void* data,
26354  EncodedLength length,
26355  NoFieldsInit,
26356  SchemaVersion version = Schema::Version)
26357  : SbeMessage(data, length, version)
26358  {
26359  checkVersion<Schema>(version);
26360  checkLength(length, version);
26361  init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
26362  resetVariableFields();
26363  }
26364 
26365  /// Creates an instance over the given memory block.
26367  void* data,
26368  EncodedLength length,
26369  NoInit)
26370  : SbeMessage(data, length)
26371  {
26372  checkCompatibility();
26373  }
26374 
26375  /// Creates an instance over the given SBE message.
26376  explicit
26378  const SbeMessage& message)
26379  : SbeMessage(message)
26380  {
26381  assert(message.valid());
26382 
26383  checkCompatibility();
26384  }
26385 
26386  /// Creates an instance over the given memory block.
26387  /// Performs no checks.
26389  void* data,
26390  EncodedLength length,
26391  NoInit,
26392  NoCheck)
26394  : SbeMessage(data, length, NoCheck())
26395  {
26396  assert(schemaId() == Schema::Id);
26397  assert(version() >= Schema::MinimalVersion);
26398  assert(TemplateId == templateId());
26399  }
26400 
26401  /// Message type = OrderMassActionReport.
26406  {
26407  return MessageType::OrderMassActionReport;
26408  }
26409 
26410  /// Message type = OrderMassActionReport.
26411 
26412  /// Common header to all inbound business messages.
26414  const OutboundBusinessHeader&
26417  {
26419 
26420  return accessOrdinary<OutboundBusinessHeader>(offset);
26421  }
26422 
26423  /// Common header to all inbound business messages.
26426  {
26428  return accessOrdinary<OutboundBusinessHeader>(offset);
26429  }
26430 
26431  /// Specifies the type of action requested.
26435  {
26437 
26438  return enumeration<MassActionType>(offset);
26439  }
26440 
26441  /// Specifies the type of action requested.
26442  ThisType&
26444  MassActionType::Enum value)
26446  {
26448 
26449  setEnumeration<MassActionType>(offset, value);
26450  return *this;
26451  }
26452 
26453  /// Specifies the scope of the action.
26455  bool
26457  MassActionScope::Enum& value) const
26459  {
26461 
26462  return enumeration<MassActionScope>(value, offset, NullUint8EnumEncoding());
26463  }
26464 
26465  /// Specifies the scope of the action.
26466  ThisType&
26468  MassActionScope::Enum value)
26470  {
26472 
26473  setEnumeration<MassActionScope>(offset, value);
26474  return *this;
26475  }
26476 
26479  {
26481 
26482  setOrdinary(offset, NullUint8EnumEncoding());
26483  return *this;
26484  }
26485 
26486  /// Unique identifier of the order as assigned by the market
26487  /// participant.
26491  {
26493 
26494  return ordinary<ClOrdID>(offset);
26495  }
26496 
26497  /// Unique identifier of the order as assigned by the market
26498  /// participant.
26499  ThisType& setClOrdId(ClOrdID value)
26501  {
26503 
26504  setOrdinary(offset, value);
26505  return *this;
26506  }
26507 
26508  /// Unique ID of Order Mass Action Report as assigned by the
26509  /// matching engine.
26513  {
26515 
26516  return ordinary<MassActionReportID>(offset);
26517  }
26518 
26519  /// Unique ID of Order Mass Action Report as assigned by the
26520  /// matching engine.
26523  {
26525 
26526  setOrdinary(offset, value);
26527  return *this;
26528  }
26529 
26530  /// Time of execution/order creation.
26534  {
26536 
26537  return ordinary<UTCTimestampNanos>(offset);
26538  }
26539 
26540  /// Time of execution/order creation.
26543  {
26545 
26546  setOrdinary(offset, value);
26547  return *this;
26548  }
26549 
26550  /// Specifies the action taken by matching engine when it
26551  /// receives the Order Mass Action Request.
26555  {
26557 
26558  return enumeration<MassActionResponse>(offset);
26559  }
26560 
26561  /// Specifies the action taken by matching engine when it
26562  /// receives the Order Mass Action Request.
26563  ThisType&
26567  {
26569 
26570  setEnumeration<MassActionResponse>(offset, value);
26571  return *this;
26572  }
26573 
26574  /// Reason Order Mass Action Request was rejected.
26576  bool
26578  MassActionRejectReason::Enum& value) const
26580  {
26582 
26583  return enumeration<MassActionRejectReason>(value, offset, NullUInt8());
26584  }
26585 
26586  /// Reason Order Mass Action Request was rejected.
26587  ThisType&
26591  {
26593 
26594  setEnumeration<MassActionRejectReason>(offset, value);
26595  return *this;
26596  }
26597 
26600  {
26602 
26603  setOrdinary(offset, NullUInt8());
26604  return *this;
26605  }
26606 
26607  /// Used to communicate event type which triggers the Order
26608  /// Mass Action Request.
26610  bool
26614  {
26616 
26617  return enumeration<ExecRestatementReasonValidForMassCancel>(value, offset, NullUint8EnumEncoding());
26618  }
26619 
26620  /// Used to communicate event type which triggers the Order
26621  /// Mass Action Request.
26622  ThisType&
26626  {
26628 
26629  setEnumeration<ExecRestatementReasonValidForMassCancel>(offset, value);
26630  return *this;
26631  }
26632 
26635  {
26637 
26638  setOrdinary(offset, NullUint8EnumEncoding());
26639  return *this;
26640  }
26641 
26642  /// Identifies the order tag identification.
26644  bool ordTagId(OrdTagID& value) const
26646  {
26648 
26649  return ordinary(value, offset, NullOrdTagID());
26650  }
26651 
26652  /// Identifies the order tag identification.
26653  ThisType& setOrdTagId(OrdTagID value)
26655  {
26657 
26658  setOrdinary(offset, value);
26659  return *this;
26660  }
26661 
26662  ThisType& setOrdTagIdToNull()
26664  {
26666 
26667  setOrdinary(offset, NullOrdTagID());
26668  return *this;
26669  }
26670 
26671  /// Side of order.
26673  bool side(Side::Enum& value) const
26675  {
26677 
26678  return enumeration<Side>(value, offset, NullChar());
26679  }
26680 
26681  /// Side of order.
26682  ThisType& setSide(Side::Enum value)
26684  {
26686 
26687  setEnumeration<Side>(offset, value);
26688  return *this;
26689  }
26690 
26691  ThisType& setSideToNull()
26693  {
26695 
26696  setOrdinary(offset, NullChar());
26697  return *this;
26698  }
26699 
26700  /// Asset associated with the security, such as DOL, BGI, OZ1,
26701  /// WDL, CNI, etc.
26703  bool asset(StrRef& value) const
26705  {
26708 
26709  return fixedStr<length>(value, offset);
26710  }
26711 
26712  /// Asset associated with the security, such as DOL, BGI, OZ1,
26713  /// WDL, CNI, etc.
26714  ThisType& setAsset(StrRef value)
26716  {
26719 
26720  setFixedStr<length>(offset, value);
26721  return *this;
26722  }
26723 
26724  ThisType& setAssetToNull()
26726  {
26729 
26730  setFixedStr<length>(offset, StrRef());
26731  return *this;
26732  }
26733 
26734  /// Security identification as defined by exchange.
26736  bool
26738  SecurityIDOptional& value) const
26740  {
26742 
26743  return ordinary(value, offset, NullSecurityIDOptional());
26744  }
26745 
26746  /// Security identification as defined by exchange.
26749  {
26751 
26752  setOrdinary(offset, value);
26753  return *this;
26754  }
26755 
26758  {
26760 
26761  setOrdinary(offset, NullSecurityIDOptional());
26762  return *this;
26763  }
26764 
26765  /// Identifies the class of the SecurityID (Exchange Symbol).
26770  {
26771  return SecurityIDSource::ExchangeSymbol;
26772  }
26773 
26774  /// Identifies the class of the SecurityID (Exchange Symbol).
26775 
26776  /// Market to which the symbol belongs.
26782  {
26783  return constructStrRef("BVMF");
26784  }
26785 
26786  /// Unique identifier of investor for mass cancel on behalf
26787  /// purposes.
26789  bool investorId(InvestorID& value) const
26791  {
26793 
26794  return ordinary(value, offset, NullInvestorID());
26795  }
26796 
26797  /// Unique identifier of investor for mass cancel on behalf
26798  /// purposes.
26799  ThisType& setInvestorId(InvestorID value)
26801  {
26803 
26804  setOrdinary(offset, value);
26805  return *this;
26806  }
26807 
26810  {
26812 
26813  setOrdinary(offset, NullInvestorID());
26814  return *this;
26815  }
26816 
26817  /// Free ASCII format text string.
26819  StrRef text() const
26821  {
26822  return getVariableLengthField(textAccess(), *this);
26823  }
26824 
26825  /// Free ASCII format text string.
26826  ThisType& setText(StrRef value)
26827  {
26828  setVariableLengthField(
26829  textAccess(),
26830  value,
26831  *this);
26832 
26833  return *this;
26834  }
26835 
26836  /// Minimal size of message body in bytes.
26839  static
26840  BlockLength
26844  {
26845  return
26846  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
26847  72;
26848  }
26849 
26850  /// Size of message body in bytes.
26853  static
26854  BlockLength
26858  {
26859  return
26860  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
26861  minimalBlockLength(version);
26862  }
26863 
26864  /// Minimal variable fields size (when variable-length fields are empty).
26868  static
26869  MessageSize
26872  {
26873  return
26874  ONIXS_B3_BOE_ASSERT(version >= Schema::MinimalVersion),
26875  static_cast<MessageSize>(TextEncoding::Size);
26876  }
26877 
26878  /// Maximal message size.
26882  static UInt64 getMaxMessageSize(UInt8)
26884  {
26885  return
26887  }
26888 
26889  /// Reset all variable-length fields if any.
26892  {
26893  setTextToNull();
26894  return *this;
26895  }
26896 
26897  /// Reset all variable-length and optional fields if any.
26898  ThisType& reset()
26900  {
26901  setMassActionScopeToNull();
26902  setMassActionRejectReasonToNull();
26903  setExecRestatementReasonToNull();
26904  setOrdTagIdToNull();
26905  setSideToNull();
26906  setAssetToNull();
26907  setSecurityIdToNull();
26908  setInvestorIdToNull();
26909 
26910  resetVariableFields();
26911  return *this;
26912  }
26913 
26914  /// \return class name.
26918  static const Char* className()
26919  {
26920  return "OrderMassActionReport702";
26921  }
26922 
26923  /// FIX message type.
26927  static StrRef fixType()
26929  {
26930  return constructStrRef(
26931  "OrderMassActionReport702");
26932  }
26933 
26934  /// \return a human-readable presentation.
26936  std::string toString() const;
26937 
26938  /// \return the end of the message.
26940  const void* tail() const
26942  {
26943  return
26944  toOpaquePtr(
26945  (text().end()));
26946  }
26947 
26948  /// \return the size occupied by the message.
26952  {
26953  return
26954  SbeMessage::calculateBinarySize(tail());
26955  }
26956 
26957 private:
26958  void checkLength(
26959  EncodedLength length, SchemaVersion version) const
26960  {
26961  const EncodedLength minimalRequiredLength =
26962  minimalBlockLength(version) +
26963  MessageHeader::Size +
26964  getMinimalVariableFieldsSize(version);
26965 
26966  checkBinaryLength(
26967  *this, length, minimalRequiredLength);
26968  }
26969 
26970  /// Checks variable fields consistency.
26971  void checkVarLenFields() const
26972  {
26973  variableLengthFields().
26974  checkTail<TextEncoding>();
26975  }
26976 
26977  void checkCompatibility() const
26978  {
26979  assert(TemplateId == templateId());
26980 
26981  checkSchema<Schema>(schemaId(), version());
26982  checkLength(bufferSize(), version());
26983  checkVarLenFields();
26984  }
26985 
26986  /// Access helper.
26987  struct textAccess
26988  {
26989  TextEncoding&
26990  operator()(
26991  const OrderMassActionReport702& obj) const
26993  {
26994  return obj.
26995  variableLengthFields().
26996  head<TextEncoding>();
26997  }
26998  };
26999 
27000  /// Reset the field.
27001  /// All the following data will be invalidated.
27002  ThisType& setTextToNull()
27004  {
27005  setVariableLengthFieldToNull(textAccess(), *this);
27006 
27007  return *this;
27008  }
27009 };
27010 
27011 
OrderCancelRequest message submits a deletion of an existing order by referencing the original client...
Definition: Messages.h:7836
const InboundBusinessHeader & businessHeader() const noexcept
Message type = SimpleModifyOrder.
Definition: Messages.h:5059
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:23064
ThisType & setExpireDate(Timestamp value) noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:7447
ThisType & setAggressorIndicator(Boolean::Enum value) noexcept
Identify whether the order initiator is an aggressor or not in the trade.
Definition: Messages.h:15955
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:5165
bool tradingSessionId(TradingSessionID::Enum &value) const noexcept
Identifier for Trading Session.
Definition: Messages.h:13794
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:12863
static constexpr const Char * className()
Definition: Messages.h:2481
ThisType & setStopPx(PriceOptional value) noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:14882
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:12087
StrRef clientIP() const noexcept
Source IP from client system.
Definition: Messages.h:273
QuoteReqID quoteReqId() const noexcept
Unique identifier for quote request.
Definition: Messages.h:18361
SchemaTraits Schema
Used template schema.
Definition: Messages.h:3674
static constexpr const Char * className()
Definition: Messages.h:4871
bool tradeId(TradeIDOptional &value) const noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:19238
const OutboundBusinessHeader & businessHeader() const noexcept
MessageType.ExecutionReport_Modify.
Definition: Messages.h:10728
DeltaInMillis keepAliveInterval() const noexcept
Longest time in milliseconds the initiator should remain silent before sending Sequence message...
Definition: Messages.h:1983
ThisType & setAllocNoOrdersType(AllocNoOrdersType::Enum value) noexcept
Indicates how the orders being booked and allocated by an Allocation Instruction. ...
Definition: Messages.h:25436
MessageCounter count() const noexcept
Number of messages to be retransmitted.
Definition: Messages.h:3825
Boolean::Enum workingIndicator() const noexcept
Indicates if an order has been triggered and is available for trading.
Definition: Messages.h:11133
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:20348
bool impliedEventId(ImpliedEventID &value) const noexcept
Unique ID for all matches that occur as a result of a implied event.
Definition: Messages.h:13992
static constexpr Side::Enum side() noexcept
Side of order.
Definition: Messages.h:24775
bool crossId(CrossIDOptional &value) const noexcept
ID of electronically submitted cross order by the institution (if in response to a cross order)...
Definition: Messages.h:10091
Legs legs(Legs::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:17375
ThisType & setSecurityStrategyType(StrRef value) noexcept
Indicates the type of Strategy created.
Definition: Messages.h:17782
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:20555
const void * tail() const noexcept
Definition: Messages.h:925
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:18110
UInt32 RejReasonOptional
Optional code to identify reason for order rejection.
Definition: Fields.h:231
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:22097
OrderCancelReplaceRequest104(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:6801
The time point without the time-zone information.
Definition: Time.h:467
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:23754
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:25619
NegotiateReject message is sent when B3 rejects a Negotiate message sent by the client.
Definition: Messages.h:968
NewOrderCross106(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:8729
NegotiateReject3 ThisType
This type alias.
Definition: Messages.h:976
ThisType & setTimeInForce(SimpleTimeInForce::Enum value) noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:4651
static constexpr const Char * className()
Definition: Messages.h:26255
ThisType & setOrigClOrdId(ClOrdIDOptional value) noexcept
ClOrdID which should be replaced.
Definition: Messages.h:5481
bool mmProtectionReset(Boolean::Enum &value) const noexcept
Resets Market Protections.
Definition: Messages.h:11509
RetransmitRequest12(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:3389
ThisType & setTradeId(TradeIDOptional value) noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:21753
ThisType & setTimestamp(UTCTimestampNanos value) noexcept
Time of request.
Definition: Messages.h:3484
Enum
Specifies how long the order remains in effect.
Definition: Fields.h:1518
#define ONIXS_B3_BOE_MESSAGING_NAMESPACE_END
Definition: ABI.h:144
ThisType & setContraBroker(Firm value) noexcept
Identifies the contra broker firm.
Definition: Messages.h:15913
Quote403(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:20043
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:10523
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:18160
ThisType & setExecId(ExecID value) noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:9684
Enum
Type of cross being submitted to a market.
Definition: Fields.h:2146
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:11968
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:5974
BidirectionalBusinessHeader & businessHeader() noexcept
Common header to all bidirectional business messages.
Definition: Messages.h:18311
ThisType & setOrderId(OrderID value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:9633
bool origClOrdId(ClOrdIDOptional &value) const noexcept
ClOrdID which should be cancelled.
Definition: Messages.h:8041
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:2129
ThisType & setClOrdId(ClOrdIDOptional value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:13174
EstablishReject6(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:2201
static constexpr MessageType::Enum messageType() noexcept
Message type = EstablishAck.
Definition: Messages.h:1902
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:16810
OrderMassActionReport702(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:26366
QuoteCancel404(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:20827
ThisType & setOrderId(OrderID value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:15933
ExecutionReportModify201(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:10650
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:23266
Operations over a repeating group instance.
Definition: SbeMessage.h:315
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:21388
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:13268
Enum
Status of Position Maintenance Request.
Definition: Fields.h:812
NewOrderSingle102 ThisType
This type alias.
Definition: Messages.h:5739
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:7175
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:20905
ThisType & setLegSide(Side::Enum value) noexcept
The side of this individual leg (multileg security).
Definition: Messages.h:17131
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:17336
Firm contraBroker() const noexcept
Broker identifier as assigned by B3 used to indicate the counterparty brokerage firm in a Forward dea...
Definition: Messages.h:18442
ThisType & setTimeInForce(TimeInForce::Enum value) noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:9897
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:26682
ThisType & setEstablishmentRejectCode(EstablishRejectCode::Enum value) noexcept
Identifies the code of reject establishment.
Definition: Messages.h:2359
const InboundBusinessHeader & businessHeader() const noexcept
Message type = SecurityDefinitionRequest.
Definition: Messages.h:17276
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:22539
QuoteID quoteId() const noexcept
Unique identifier for quote.
Definition: Messages.h:19217
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:1714
AllocationInstruction601(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:24558
ThisType & setPrice(Price8Optional value) noexcept
Price per share or contract.
Definition: Messages.h:19465
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:19165
UInt64 BusinessRejectRefID
Value of business-level identification field on the message being referenced.
Definition: Fields.h:275
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:8663
Enum
Identifies the code of reject establishment.
Definition: Fields.h:1236
Terminate7(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:2577
SchemaTraits Schema
Used template schema.
Definition: Messages.h:14317
ThisType & setSecurityResponseType(SecurityResponseType::Enum value) noexcept
Type of Security Definition message response.
Definition: Messages.h:17758
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:3302
bool maxFloor(QuantityOptional &value) const noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:14932
OrderMassActionReport702(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:26352
NewOrderCross106(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:8718
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const noexcept
Identifier for the instrument status.
Definition: Messages.h:13860
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:14111
ThisType & setMmProtectionReset(Boolean::Enum value) noexcept
Resets Market Protections.
Definition: Messages.h:11522
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:17911
#define ONIXS_B3_BOE_LTWT_STRUCT
Definition: ABI.h:88
bool massActionRejectReason(MassActionRejectReason::Enum &value) const noexcept
Reason Order Mass Action Request was rejected.
Definition: Messages.h:26577
OrderMassActionReport message is used to acknowledge an OrderMassActionRequest message.
Definition: Messages.h:26320
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:5145
static constexpr MessageType::Enum messageType() noexcept
Message type = PositionMaintenanceRequest.
Definition: Messages.h:22910
ThisType & setCancelOnDisconnectType(CancelOnDisconnectType::Enum value) noexcept
Criteria used to initiate cancel on disconnect mechanism by the gateway.
Definition: Messages.h:1595
bool routingInstruction(RoutingInstruction::Enum &value) const noexcept
Indicates additional order instruction.
Definition: Messages.h:6123
StrRef credentials() const noexcept
Credentials to identify/authenticate the client. The format is a JSON with the following data: { "aut...
Definition: Messages.h:263
ThisType & setReceivedTime(UTCTimestampNanosOptional value) noexcept
Time of receipt of related inbound message in the gateway.
Definition: Messages.h:15038
SessionID sessionId() const noexcept
Message type = Terminate.
Definition: Messages.h:2640
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:15729
ThisType & setExecuteUnderlyingTradeToNull() noexcept
Definition: Messages.h:18553
UInt64 ClOrdIDOptional
Optional unique identifier of the order as assigned by the market participant.
Definition: Fields.h:97
bool clOrdId(ClOrdIDOptional &value) const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:15634
Establish4(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:1387
Sent by client system to replace an existing order.
Definition: Messages.h:6733
SessionVerID sessionVerId() const noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:2304
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:3327
ThisType & setExecRefId(ExecIDOptional value) noexcept
Optionally sent when reporting a trade bust.
Definition: Messages.h:13689
StrRef clientAppVersion() const noexcept
Application version as informed during certification process.
Definition: Messages.h:291
EstablishReject6(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:2241
static constexpr const Char * className()
Definition: Messages.h:2120
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:20370
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:18463
PosType::Enum posType() const noexcept
Used to identify the type of quantity.
Definition: Messages.h:23507
The client sends the Negotiate message to B3 to initiate a connection. Negotiate is the first message...
Definition: Messages.h:33
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:25586
ThisType & setPosReqId(PosReqID value) noexcept
Unique identifier for the position maintenance request.
Definition: Messages.h:22948
ThisType & setAllocId(AllocID value) noexcept
Unique identifier for this allocation instruction message.
Definition: Messages.h:25306
UTCTimestampNanos timestamp() const noexcept
Time of request.
Definition: Messages.h:178
ThisType & setPrice(PriceOptional value) noexcept
Price per share or contract.
Definition: Messages.h:4727
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:19365
ThisType & setExecId(ExecID value) noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:12155
static constexpr MessageType::Enum messageType() noexcept
MessageType.ExecutionReport_Cancel.
Definition: Messages.h:11939
ThisType & setSecurityId(SecurityIDOptional value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:26747
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:12773
SidesEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:8467
Quantity allocQty() const noexcept
Quantity allocated to specific sub-account.
Definition: Messages.h:24935
Timestamp localMktDateToTimestamp(LocalMktDate days) noexcept
Converts days since epoch to Timestamp value.
Definition: Fields.h:2554
ThisType & setQuoteReqId(QuoteReqID value) noexcept
Unique identifier for quote request.
Definition: Messages.h:21702
SecurityDefinitionRequest300 ThisType
This type alias.
Definition: Messages.h:17009
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:24348
ThisType & setMaxFloor(QuantityOptional value) noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:6277
static constexpr Boolean::Enum privateQuote() noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:22008
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:21673
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:25577
ThisType & setRequestTimestamp(UTCTimestampNanos value) noexcept
Matches Negotiate timestamp.
Definition: Messages.h:3794
ThisType & setCrossId(CrossIDOptional value) noexcept
ID of electronically submitted cross order by the institution (if in response to a cross order)...
Definition: Messages.h:14973
bool executingTrader(StrRef &value) const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:6297
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:17460
ThisType & setMarketSegmentReceivedTime(UTCTimestampNanosOptional value) noexcept
Time of receipt of related inbound message in the market segment path.
Definition: Messages.h:11002
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:1235
OrderCancelRequest105 ThisType
This type alias.
Definition: Messages.h:7844
SecurityDefinitionResponse301(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:17619
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:5550
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:15059
ThisType & setMultiLegReportingType(MultiLegReportingType::Enum value) noexcept
Used to indicate what an Execution Report represents.
Definition: Messages.h:13505
bool quoteRequestRejectReason(RejReasonOptional &value) const noexcept
Reason Quote was rejected.
Definition: Messages.h:21623
const OutboundBusinessHeader & businessHeader() const noexcept
MessageType.ExecutionReport_Cancel.
Definition: Messages.h:11950
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:19746
ExecutionReportTrade203(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:13056
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:3614
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:5912
bool expireDate(Timestamp &value) const noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:9909
Sequence9(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:3166
OrdType::Enum ordType() const noexcept
Order type.
Definition: Messages.h:6082
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:17170
ThisType & setSessionVerId(SessionVerID value) noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:723
OrderMassActionReport702(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:26337
ThisType & setLongQty(QuantityOptional value) noexcept
Long Quantity.
Definition: Messages.h:23536
GroupSizeEncoding::BlockLength BlockLength
Type to present the length of binary data of the repeating group entry.
Definition: SbeMessage.h:319
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:8806
ThisType & setExecId(ExecID value) noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:10935
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:21424
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:13251
ThisType & setOrdType(OrdType::Enum value) noexcept
Order type.
Definition: Messages.h:9877
Percentage8 fixedRate() const noexcept
Interest rate of the forward trade.
Definition: Messages.h:20414
ThisType & setQuoteStatus(QuoteStatus::Enum value) noexcept
Identifies the status of the quote acknowledgement.
Definition: Messages.h:19319
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:6054
StrRef text() const noexcept
Free ASCII format text string.
Definition: Messages.h:15196
ThisType & setContraryInstructionIndicator(Boolean::Enum value) noexcept
Used to indicate when a contrary instruction for exercise or abandonment is being submitted :The exer...
Definition: Messages.h:24152
bool maxFloor(QuantityOptional &value) const noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:7336
ThisType & setStopPx(PriceOptional value) noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:7286
IntegralConstant< UInt64, 0ULL > NullPosMaintRptIDOptional
Null value for an optional PosMaintRptIDOptional field.
Definition: Fields.h:2462
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:21463
SchemaTraits Schema
Used template schema.
Definition: Messages.h:7841
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:11485
ThisType & setExecRefId(ExecIDOptional value) noexcept
Optionally sent when reporting a trade bust.
Definition: Messages.h:16104
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:12115
ExecutionReportNew200(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:9430
bool routingInstruction(RoutingInstruction::Enum &value) const noexcept
Indicates additional order instruction.
Definition: Messages.h:7134
ThisType & setCrossedIndicatorToNull() noexcept
Definition: Messages.h:8977
SchemaTraits Schema
Used template schema.
Definition: Messages.h:8438
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:21497
SessionID sessionId() const noexcept
Message type = NegotiateReject.
Definition: Messages.h:1063
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:3552
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:3774
ThisType & setCrossType(CrossType::Enum value) noexcept
Type of cross being submitted to a market.
Definition: Messages.h:8999
PositionMaintenanceCancelRequest501(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:22452
Retransmission13(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:3715
PosMaintRptID posMaintRptId() const noexcept
Unique identifier for this position report.
Definition: Messages.h:23795
ThisType & setAllocReportType(AllocReportType::Enum value) noexcept
Describes the specific type or purpose of an Allocation Report message.
Definition: Messages.h:25412
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:8872
ThisType & setCxlRejResponseTo(CxlRejResponseTo::Enum value) noexcept
Identifies the type of request that this Cancel Reject is in response to.
Definition: Messages.h:14468
ThisType & setTradeId(TradeID value) noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:15893
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:24981
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:8602
AllocNoOrdersType::Enum allocNoOrdersType() const noexcept
Indicates how the orders being booked and allocated by an Allocation Instruction. ...
Definition: Messages.h:25425
ExecutionReportTrade203(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:13027
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:4082
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:17938
ExecutionReportModify201(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:10665
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:20402
DeltaInMillis keepAliveInterval() const noexcept
Longest time in milliseconds the initiator should remain silent before sending Sequence message...
Definition: Messages.h:1538
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:1249
ThisType & setMaxFloor(QuantityOptional value) noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:11392
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:19177
ThisType & setOrdType(OrdType::Enum value) noexcept
Order type.
Definition: Messages.h:11199
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:23221
ThisType & setExecRestatementReason(ExecRestatementReason::Enum value) noexcept
Indicates reason of cancelation, if available.
Definition: Messages.h:12332
UInt16 DaysToSettlementOptional
Optional deadline for completing the forward deal.
Definition: Fields.h:195
SessionVerID sessionVerId() const noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:1938
ThisType & setContraBroker(Firm value) noexcept
Identifies the contra broker firm.
Definition: Messages.h:13557
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:10832
ThisType & setLastIncomingSeqNo(SeqNumOptional value) noexcept
If establishmentRejectCode = EstablishRejectCode.INVALID_NEXTSEQNO, indicates the application sequenc...
Definition: Messages.h:2388
bool securityTradingStatus(SecurityTradingStatus::Enum &value) const noexcept
Identifier for the instrument status.
Definition: Messages.h:16252
UInt64 MassActionReportID
Unique ID of Order Mass Action Report as assigned by the matching engine.
Definition: Fields.h:281
ThisType & setExecRestatementReasonToNull() noexcept
Definition: Messages.h:8112
AllocID allocId() const noexcept
Unique identifier for this allocation instruction message.
Definition: Messages.h:24625
ThisType & setAllocQty(Quantity value) noexcept
Quantity allocated to specific sub-account.
Definition: Messages.h:24944
bool crossPrioritization(CrossPrioritization::Enum &value) const noexcept
Indicates if one side or the other of a cross order should be prioritized.
Definition: Messages.h:9021
SbeGroup< LegsEntry, GroupSizeEncoding, MessageSize > Legs
Repeating group containing LegsEntry entries.
Definition: Messages.h:17192
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:17480
The SecurityDefinitionRequest message creates a User Defined Spread (UDS) instrument. User-Defined Spreads provide users of the electronic trading platform the ability to create strategies composed by their choice of leg instruments, leg ratio and leg side.
Definition: Messages.h:17001
ThisType & setSettlType(SettlType::Enum value) noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:20308
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:20215
static constexpr MessageType::Enum messageType() noexcept
Message type = QuoteRequestReject.
Definition: Messages.h:21593
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:21025
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:10545
Establish4(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:1402
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:15697
SessionID sessionId() const noexcept
Message type = EstablishAck.
Definition: Messages.h:1913
ThisType & setImpliedEventId(ImpliedEventID value)
Unique ID for all matches that occur as a result of a implied event.
Definition: Messages.h:14003
UInt64 ExecID
Unique identifier of execution message as assigned by exchange.
Definition: Fields.h:201
MassActionResponse::Enum massActionResponse() const noexcept
Specifies the action taken by matching engine when it receives the Order Mass Action Request...
Definition: Messages.h:26553
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:11767
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:24301
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:12124
UInt32 SessionIDOptional
Optional client connection identification on the gateway assigned by B3.
Definition: Fields.h:109
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:24088
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:3079
ThisType & setCustodianInfoToNull() noexcept
Definition: Messages.h:6387
ThisType & setTradingSessionSubId(TradingSessionSubID::Enum value) noexcept
Identifier for the instrument group phase.
Definition: Messages.h:16230
StrRef executingTrader() const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:20392
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:26532
static constexpr const Char * className()
Definition: Messages.h:1725
bool mmProtectionReset(Boolean::Enum &value) const noexcept
Resets Market Protections.
Definition: Messages.h:10286
SimpleModifyOrder101(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:4981
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:18194
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:4758
ThisType & setExecuteUnderlyingTrade(ExecuteUnderlyingTrade::Enum value) noexcept
Specifies if a simultaneous trade of the underlying is to be performed.Required to indicate Termo Vis...
Definition: Messages.h:20450
ThisType & setSettlType(SettlType::Enum value) noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:19434
OrderMassActionRequest701(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:25808
static constexpr MessageType::Enum messageType() noexcept
Message type = NewOrderCross.
Definition: Messages.h:8745
static constexpr const Char * className()
Definition: Messages.h:3045
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:17897
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:13259
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:18573
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:20277
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:19290
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:12834
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:21928
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:5077
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:2102
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:9704
QuoteRequestReject405(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:21566
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:23470
Execution Report - Reject message notifies the reason a client request was not accepted by Matching E...
Definition: Messages.h:14312
Terminate message is sent to indicate that the sender is going to disconnect the TCP socket connectio...
Definition: Messages.h:2545
bool allocRejCode(RejReasonOptional &value) const noexcept
Identifies reason for rejection.
Definition: Messages.h:25448
ThisType & setDaysToSettlement(DaysToSettlementOptional value) noexcept
Deadline for completing the forward deal.
Definition: Messages.h:16035
bool strategyId(StrategyIDOptional &value) const noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:6430
ThisType & setPosReqId(PosReqIDOptional value) noexcept
Unique identifier for the position maintenance request.
Definition: Messages.h:23734
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:26841
QuoteCancel404(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:20838
ThisType & setTimeInForce(TimeInForce::Enum value) noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:12417
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:24049
RetransmitReject message is sent when a RetransmitRequest message is rejected by B3. More details are described in the Message Specification Guidelines document.
Definition: Messages.h:3977
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:14568
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:20635
UInt64 OrderIDOptional
Optional exchange-generated order identifier.
Definition: Fields.h:219
QuoteRequestReject405(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:21555
ExecutionReportReject204(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:14344
bool account(AccountOptional &value) const noexcept
Identifies the type of quote cancel.
Definition: Messages.h:20996
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:12922
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:6568
PositionMaintenanceReport503(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:23658
const BidirectionalBusinessHeader & businessHeader() const noexcept
Message type = TermoQuote.
Definition: Messages.h:20106
const void * tail() const noexcept
Definition: Messages.h:5659
bool tradingSessionSubId(TradingSessionSubID::Enum &value) const noexcept
Identifier for the instrument group phase.
Definition: Messages.h:13827
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:18121
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:4846
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:20566
ThisType & setNextSeqNo(SeqNum value) noexcept
The next application sequence number to be produced by the client.
Definition: Messages.h:1571
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:3874
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:26125
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:7627
Interval time expressed in milliseconds.
Definition: Composites.h:701
MessageSize BlockLength
Length of the message body representing a block of fixed-length fields.
Definition: SbeMessage.h:1139
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:21795
bool accountType(AccountType::Enum &value) const noexcept
Type of account associated with an order.
Definition: Messages.h:7398
ThisType & setExecId(ExecID value) noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:13339
BidirectionalBusinessHeader & businessHeader() noexcept
Common header to all bidirectional business messages.
Definition: Messages.h:20116
SimpleNewOrder100(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:4300
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:19896
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:6062
ThisType & setPrice(PriceOptional value) noexcept
Price per share or contract.
Definition: Messages.h:5423
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:8649
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:10797
const void * tail() const noexcept
Definition: Messages.h:3314
ExecutionReport - Cancel message is sent in response to Order Cancel Request as well as to report uns...
Definition: Messages.h:11855
Execution Report - New message is sent in response to a NewOrderSingle or SimpleNewOrder messages...
Definition: Messages.h:9384
SimpleNewOrder100 ThisType
This type alias.
Definition: Messages.h:4276
NewOrderSingle102(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:5763
bool crossedIndicator(CrossedIndicator::Enum &value) const noexcept
Indicates cross order purpose.
Definition: Messages.h:8956
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:4460
ThisType & setSecurityId(SecurityIDOptional value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:17706
ThisType & setText(StrRef value)
Free ASCII format text string.
Definition: Messages.h:24248
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:22668
ThisType & setRequestTimestamp(UTCTimestampNanos value) noexcept
Matches Negotiate timestamp.
Definition: Messages.h:743
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:3902
Sequence9(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:3155
Timestamp clearingBusinessDate() const noexcept
The &#39;Clearing Business Date&#39; referred to by this request.
Definition: Messages.h:23973
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:4381
MessageHeader::Version SchemaVersion
SBE-encoded data version type.
Definition: SchemaTraits.h:30
#define ONIXS_B3_BOE_NOTHROW
Definition: Compiler.h:182
ThisType & setQuoteReqId(QuoteReqID value) noexcept
Unique identifier for quote request.
Definition: Messages.h:19206
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:10471
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:23309
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:5984
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:8905
SchemaTraits Schema
Used template schema.
Definition: Messages.h:16564
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:6021
RetransmitReject14 ThisType
This type alias.
Definition: Messages.h:3985
TimeInForce::Enum timeInForce() const noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:14749
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:6904
Execution Report - Modify message is sent in response to OrderCancelReplaceRequest or SimpleModifyOrd...
Definition: Messages.h:10633
static constexpr AccountType::Enum accountType() noexcept
Type of account associated with an order.
Definition: Messages.h:5533
static constexpr const Char * className()
Definition: Messages.h:8314
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:5195
const void * tail() const noexcept
Definition: Messages.h:1746
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:25034
const InboundBusinessHeader & businessHeader() const noexcept
Message type = PositionMaintenanceRequest.
Definition: Messages.h:22921
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:12019
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:24817
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:17739
ThisType & setPosTransType(PosTransType::Enum value) noexcept
Identifies the type of position transaction.
Definition: Messages.h:23824
ThisType & setExecutingTraderToNull() noexcept
Definition: Messages.h:6317
const InboundBusinessHeader & businessHeader() const noexcept
Message type = OrderCancelRequest.
Definition: Messages.h:7931
const OutboundBusinessHeader & businessHeader() const noexcept
Message type = OrderMassActionReport.
Definition: Messages.h:26415
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:21248
SimpleModifyOrder101(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:5021
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:4139
UInt64 SecurityReqRespID
Unique ID of a Security Definition Request/Response.
Definition: Fields.h:269
OrdStatus::Enum ordStatus() const noexcept
Identifies current status of order.
Definition: Messages.h:11988
Quantity cumQty() const noexcept
Total number of shares or contracts filled.
Definition: Messages.h:15862
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:18150
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:9205
ThisType & setPrice(Price8Optional value) noexcept
Price per share or contract.
Definition: Messages.h:21879
Quantity cumQty() const noexcept
Total number of shares or contracts filled.
Definition: Messages.h:10966
SchemaTraits Schema
Used template schema.
Definition: Messages.h:19018
bool totNoRelatedSym(TotNoRelatedSym &value) const noexcept
Number of leg fill notice messages sent with spread summary.
Definition: Messages.h:13611
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:4800
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:14053
bool orderId(OrderIDOptional &value) const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:8012
Positions positions(Positions::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:24180
bool tradingSessionSubId(TradingSessionSubID::Enum &value) const noexcept
Identifier for the instrument group phase.
Definition: Messages.h:16219
ThisType & setSemanticVersion(Version value)
Identifies the semantic version of the schema used in this session.
Definition: Messages.h:812
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:14023
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:18320
ThisType & setText(StrRef value)
Free ASCII format text string.
Definition: Messages.h:15225
OrderMassActionRequest701(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:25833
bool price(PriceOptional &value) const noexcept
Price per share or contract.
Definition: Messages.h:5413
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:24078
EstablishAck5(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:1835
QuoteRequest401(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:18252
UInt16 DaysToSettlement
Deadline for completing the forward deal.
Definition: Fields.h:187
ThisType & setCumQty(Quantity value) noexcept
Total number of shares or contracts filled.
Definition: Messages.h:15871
ThisType & setExecRestatementReason(ExecRestatementReasonValidForMassCancel::Enum value) noexcept
Used to communicate event type which triggers the Order Mass Action Request.
Definition: Messages.h:26623
static constexpr const Char * className()
Definition: Messages.h:14192
ThisType & setOrdStatus(OrdStatus::Enum value) noexcept
Identifies current status of order.
Definition: Messages.h:10775
BusinessMessageReject206(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:16576
static constexpr MessageType::Enum messageType() noexcept
MessageType.ExecutionReport_New.
Definition: Messages.h:9468
Negotiate1(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:101
const InboundBusinessHeader & businessHeader() const noexcept
Message type = NewOrderCross.
Definition: Messages.h:8756
ExecutionReportReject204 ThisType
This type alias.
Definition: Messages.h:14320
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:16174
ThisType & setExecRestatementReason(ExecRestatementReasonValidForMassCancel::Enum value) noexcept
Used to communicate event type which triggers the Order Mass Action Request.
Definition: Messages.h:25980
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:7497
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:18757
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:14598
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:16448
ThisType & setCumQty(Quantity value) noexcept
Total number of shares or contracts filled.
Definition: Messages.h:10975
bool shortQty(QuantityOptional &value) const noexcept
Short Quantity.
Definition: Messages.h:23556
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:23332
ThisType & setOrigPosReqRefId(PosReqIDOptional value) noexcept
Reference to the PosReqID (710) of a previous maintenance request that is being cancelled.
Definition: Messages.h:22591
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:25597
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:8850
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:22930
ThisType & setFixedRate(Percentage8 value) noexcept
Describes the interest to be paid by the forward buyer and received by the forward seller...
Definition: Messages.h:18667
static constexpr const Char * className()
Definition: Messages.h:1306
bool strategyId(StrategyIDOptional &value) const noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:13961
Timestamp tradeDate() const noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:12275
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:21685
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:24237
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:18900
Boolean::Enum aggressorIndicator() const noexcept
Identify whether the order initiator is an aggressor or not in the trade.
Definition: Messages.h:15945
bool expireDate(Timestamp &value) const noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:11231
PosTransType::Enum posTransType() const noexcept
Identifies the type of position transaction.
Definition: Messages.h:23086
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:16353
ExecutionReportCancel202(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:11912
AllocationInstruction601(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:24569
ThisType & setLeavesQty(Quantity value) noexcept
Amount of shares open for further execution, or unexecuted.
Definition: Messages.h:15851
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:8145
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:1340
ThisType & setOrderCategory(OrderCategory::Enum value) noexcept
Reason why a trade occurred.
Definition: Messages.h:13470
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:16412
UInt64 CrossID
Identifier for a cross order.
Definition: Fields.h:327
ThisType & setOrdStatus(OrdStatus::Enum value) noexcept
Identifies current status of order.
Definition: Messages.h:15622
SbeGroup< SidesEntry, GroupSizeEncoding, MessageSize > Sides
Repeating group containing SidesEntry entries.
Definition: Messages.h:18217
bool tradeDate(Timestamp &value) const noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:24854
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:17452
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:17053
ExecutionReportForward205(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:15548
ThisType & setPrice(PriceOptional value) noexcept
Price per share or contract.
Definition: Messages.h:12499
SchemaTraits Schema
Used template schema.
Definition: Messages.h:38
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:2650
Terminate7 ThisType
This type alias.
Definition: Messages.h:2553
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:9271
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:3275
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:138
SchemaTraits Schema
Used template schema.
Definition: Messages.h:20775
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:15068
QuoteReqID quoteReqId() const noexcept
Unique identifier for quote request.
Definition: Messages.h:19197
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:24211
QuoteRequest401(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:18274
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:10746
const InboundBusinessHeader & businessHeader() const noexcept
Message type = AllocationInstruction.
Definition: Messages.h:24607
static constexpr MessageType::Enum messageType() noexcept
Message type = SecurityDefinitionRequest.
Definition: Messages.h:17265
PositionMaintenanceRequest502 ThisType
This type alias.
Definition: Messages.h:22834
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:20134
Enum
Indicates how the orders being booked and allocated by an Allocation Instruction. ...
Definition: Fields.h:504
EstablishReject6 ThisType
This type alias.
Definition: Messages.h:2192
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:6954
Sequence9 ThisType
This type alias.
Definition: Messages.h:3117
UInt64 CrossIDOptional
Identifier for a cross order.
Definition: Fields.h:333
ExecutionReportModify201(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:10690
ThisType & setCrossTypeToNull() noexcept
Definition: Messages.h:9008
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:6986
const void * tail() const noexcept
Definition: Messages.h:20676
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:16395
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:5853
ThisType & setExecuteUnderlyingTrade(ExecuteUnderlyingTrade::Enum value) noexcept
Specifies if a simultaneous trade of the underlying is to be performed.Required to indicate Termo Vis...
Definition: Messages.h:18543
bool enteringFirm(FirmOptional &value) const noexcept
Identifies the broker firm that will enter orders.
Definition: Messages.h:8551
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:16868
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:20592
bool executeUnderlyingTrade(ExecuteUnderlyingTrade::Enum &value) const noexcept
Specifies if a simultaneous trade of the underlying is to be performed.Required to indicate Termo Vis...
Definition: Messages.h:18530
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:5304
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:20319
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:860
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:7596
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:1923
Enum
Specifies the type of action requested.
Definition: Fields.h:703
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:4177
Terminate7(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:2602
SessionID sessionId() const noexcept
Message type = RetransmitRequest.
Definition: Messages.h:3452
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:8240
PositionMaintenanceRequest502(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:22883
RejReason ordRejReason() const noexcept
Code to identify reason for order rejection.
Definition: Messages.h:14577
bool execRestatementReason(ExecRestatementReason::Enum &value) const noexcept
Indicates reason of cancelation, if available.
Definition: Messages.h:12321
Quote403(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:20079
ExecutionReportReject204(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:14329
RejReason businessRejectReason() const noexcept
Code to identify the reason of the rejection.
Definition: Messages.h:16749
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:12075
QuoteRequest401 ThisType
This type alias.
Definition: Messages.h:18041
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:6645
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:12854
ThisType & setQuoteRequestRejectReasonToNull() noexcept
Definition: Messages.h:21641
const InboundBusinessHeader & businessHeader() const noexcept
Message type = OrderMassActionRequest.
Definition: Messages.h:25871
static constexpr const Char * className()
Definition: Messages.h:3605
SimpleTimeInForce::Enum timeInForce() const noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:5337
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:6155
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:11618
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:9604
UInt16 BlockLength
Root block length.
Definition: Composites.h:127
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:4213
SBE-encoded repeating group.
Definition: SbeMessage.h:649
OrderCancelRequest105(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:7882
ThisType & setOrderId(OrderID value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:13577
ExecutionReportModify201(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:10701
NotApplied8(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:2860
const OutboundBusinessHeader & businessHeader() const noexcept
MessageType.ExecutionReport_New.
Definition: Messages.h:9479
ThisType & setTradeId(TradeIDOptional value) noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:18421
SchemaTraits Schema
Used template schema.
Definition: Messages.h:24517
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:2289
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:21226
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:4705
SeqNum fromSeqNo() const noexcept
Message type = NotApplied.
Definition: Messages.h:2937
Quote message is used as the response to a QuoteRequest message, tradeable, and restricted tradeable ...
Definition: Messages.h:20011
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:24038
bool settlType(SettlType::Enum &value) const noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:21838
ThisType & setMultiLegReportingType(MultiLegReportingType::Enum value) noexcept
Used to indicate what an Execution Report represents.
Definition: Messages.h:9847
UTCTimestampNanos requestTimestamp() const noexcept
Matches Negotiate timestamp.
Definition: Messages.h:2328
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:15282
TimeInForce::Enum timeInForce() const noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:11210
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:18783
bool stopPx(PriceOptional &value) const noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:12520
SessionVerID sessionVerId() const noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:153
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:1264
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:19874
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:14556
EstablishAck5(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:1864
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:25022
UInt64 PosReqIDOptional
Optional unique identifier for the position maintenance request.
Definition: Fields.h:263
ThisType & setRoutingInstruction(RoutingInstruction::Enum value) noexcept
Indicates additional order instruction.
Definition: Messages.h:7145
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:26541
Enum
Specifies if a simultaneous trade of the underlying is to be performed.
Definition: Fields.h:843
LocalMktDate timestampToLocalMktDate(const Timestamp &timestamp) noexcept
Definition: Fields.h:2562
ThisType & setAllocTransType(AllocTransType::Enum value) noexcept
Identifies allocation transaction type.
Definition: Messages.h:25388
ThisType & setOrdType(OrdType::Enum value) noexcept
Order type.
Definition: Messages.h:6091
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:19693
OrdType::Enum ordType() const noexcept
Order type.
Definition: Messages.h:14729
SessionID sessionId() const noexcept
Message type = RetransmitReject.
Definition: Messages.h:4072
PositionMaintenanceCancelRequest501(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:22438
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:695
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:24275
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:24963
bool execRestatementReason(ExecRestatementReasonValidForMassCancel::Enum &value) const noexcept
Used to communicate event type which triggers the Order Mass Action Request.
Definition: Messages.h:25968
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:10841
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:12791
bool price(PriceOptional &value) const noexcept
Price per share or contract.
Definition: Messages.h:9969
bool massActionScope(MassActionScope::Enum &value) const noexcept
Specifies the scope of the action.
Definition: Messages.h:26456
ThisType & setExpireDate(Timestamp value) noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:14789
SchemaTraits Schema
Used template schema.
Definition: Messages.h:18038
IntegralConstant< UInt32, 0 > NullSeqNumOptional
Null value for an optional SeqNumOptional field.
Definition: Fields.h:2408
StrRef executingTrader() const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:21950
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:5254
ThisType & setRefSeqNum(SeqNum value) noexcept
Message sequence number of rejected message.
Definition: Messages.h:16701
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:26898
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:1276
ThisType & setCrossId(CrossIDOptional value) noexcept
ID of electronically submitted cross order by the institution (if in response to a cross order)...
Definition: Messages.h:10101
Enum
Describes the action that triggered this specific Execution Report - see the OrdStatus (39) tag for t...
Definition: Fields.h:1642
const void * tail() const noexcept
Definition: Messages.h:2502
Enum
Identifies the code of termination.
Definition: Fields.h:1300
ThisType & setAccountToNull() noexcept
Definition: Messages.h:20337
Enum
Maintenance Action to be performed.
Definition: Fields.h:896
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:18854
ThisType & setQuoteRejectReason(RejReasonOptional value) noexcept
Reason Quote was rejected.
Definition: Messages.h:19136
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:22968
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:15342
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:16471
bool lastIncomingSeqNo(SeqNumOptional &value) const noexcept
If establishmentRejectCode = EstablishRejectCode.INVALID_NEXTSEQNO, indicates the application sequenc...
Definition: Messages.h:2375
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:6516
const OutboundBusinessHeader & businessHeader() const noexcept
Message type = AllocationReport.
Definition: Messages.h:25279
ThisType & setAllocNoOrdersType(AllocNoOrdersType::Enum value) noexcept
Indicates how the orders being booked and allocated by an Allocation Instruction. ...
Definition: Messages.h:24742
const InboundBusinessHeader & businessHeader() const noexcept
Message type = PositionMaintenanceCancelRequest.
Definition: Messages.h:22501
ThisType & setExecuteUnderlyingTradeToNull() noexcept
Definition: Messages.h:19630
ThisType & setReceivedTime(UTCTimestampNanosOptional value) noexcept
Time of receipt of related inbound message in the gateway.
Definition: Messages.h:12622
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:22731
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:21960
const void * tail() const noexcept
Definition: Messages.h:2141
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Definition: Messages.h:23601
ThisType & setLeavesQty(Quantity value) noexcept
Amount of shares open for further execution, or unexecuted.
Definition: Messages.h:13381
CrossID crossId() const noexcept
ID of electronically submitted cross order by the institution (if in response to a cross order)...
Definition: Messages.h:8775
Establish4(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:1416
SecurityDefinitionResponse301(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:17630
Enum
Identifies status of allocation.
Definition: Fields.h:526
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for mass cancel on behalf purposes.
Definition: Messages.h:26146
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:22120
bool strategyId(StrategyIDOptional &value) const noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:10320
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:17324
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:5392
Boolean::Enum aggressorIndicator() const noexcept
Identify whether the order initiator is an aggressor or not in the trade.
Definition: Messages.h:13413
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:26644
static constexpr FlowType::Enum serverFlow() noexcept
Type of flow from client to server.
Definition: Messages.h:756
static constexpr MessageType::Enum messageType() noexcept
Message type = QuoteStatusReport.
Definition: Messages.h:19097
ThisType & setPrice(PriceOptional value) noexcept
Price per share or contract.
Definition: Messages.h:6186
ThisType & setStrategyId(StrategyIDOptional value) noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:10330
static constexpr const Char * className()
Definition: Messages.h:15333
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:25317
StrRef text() const noexcept
Free ASCII format text string.
Definition: Messages.h:24219
const void * tail() const noexcept
Definition: Messages.h:8335
const void * tail() const noexcept
Definition: Messages.h:19886
SchemaTraits Schema
Used template schema.
Definition: Messages.h:23448
IntegralConstant< UInt16, 65535 > NullDaysToSettlementOptional
Null value for an optional DaysToSettlementOptional field.
Definition: Fields.h:2438
SbeGroup< PositionsEntry, GroupSizeEncoding, MessageSize > Positions
Repeating group containing PositionsEntry entries.
Definition: Messages.h:23623
ThisType & setSecurityTradingStatus(SecurityTradingStatus::Enum value) noexcept
Identifier for the instrument status.
Definition: Messages.h:16263
ThisType & setOrdType(OrdType::Enum value) noexcept
Order type.
Definition: Messages.h:12397
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:14061
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:22959
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:10395
ThisType & setProtectionPrice(PriceOptional value) noexcept
Conditionally returned on execution reports for Market and Stop Protect orders.
Definition: Messages.h:9767
StrRef legSymbol() const noexcept
Multileg instrument&#39;s individual security’s Symbol.
Definition: Messages.h:17065
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:21147
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:26780
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:2461
ThisType & setPrice(Price value) noexcept
Price per share or contract.
Definition: Messages.h:8944
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:18584
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:3018
ThisType & setPosMaintAction(PosMaintAction::Enum value) noexcept
Maintenance Action to be performed.
Definition: Messages.h:23845
Price8 price() const noexcept
Price per share or contract.
Definition: Messages.h:18484
SimpleModifyOrder101(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:5010
Enum
Identifies allocation transaction type.
Definition: Fields.h:435
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:22656
Quantity lastQty() const noexcept
Quantity of shares bought/sold on the last fill.
Definition: Messages.h:13288
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:5923
Timestamp tradeDate() const noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:11110
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:22203
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:5962
ThisType & setMmProtectionReset(Boolean::Enum value) noexcept
Resets Market Protections.
Definition: Messages.h:6892
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:19723
The QuoteRequestReject message is used when a QuoteRequest is not accept by B3 due to missing or inco...
Definition: Messages.h:21336
OutboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:26424
ThisType & setSecondaryOrderId(OrderID value) noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:9572
OutboundBusinessHeader & businessHeader() noexcept
Common header to all outbound business messages.
Definition: Messages.h:15584
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:20626
ThisType & setCrossPrioritization(CrossPrioritization::Enum value) noexcept
Indicates if one side or the other of a cross order should be prioritized.
Definition: Messages.h:10261
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:6505
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:25945
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:7614
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:26653
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:23292
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:4372
Sequence9(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:3177
bool tradingSessionId(TradingSessionID::Enum &value) const noexcept
Identifier for Trading Session.
Definition: Messages.h:16186
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:4238
bool secondaryOrderId(OrderIDOptional &value) const noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:14504
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:11977
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:10360
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:23495
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:16839
bool posReqId(PosReqIDOptional &value) const noexcept
Unique identifier for the position maintenance request.
Definition: Messages.h:23725
SecurityDefinitionRequest300(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:17213
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:8818
UInt32 RejReason
Code to identify reason for order rejection.
Definition: Fields.h:225
bool expireDate(Timestamp &value) const noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:14770
static constexpr MessageType::Enum messageType() noexcept
Message type = Retransmission.
Definition: Messages.h:3753
ThisType & setTradeDate(Timestamp value) noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:12285
ThisType & setPrice(PriceOptional value) noexcept
Price per share or contract.
Definition: Messages.h:14851
ExecutionReportTrade203(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:13078
Enum
Type of Security Definition message response.
Definition: Fields.h:784
Enum
Defines message type.
Definition: Fields.h:1011
bool posMaintRptRefId(PosMaintRptIDOptional &value) const noexcept
Reference to a PosMaintRptID (721) from a previous Position Maintenance Report that is being cancelle...
Definition: Messages.h:22613
The SimpleModifyOrder submits a simple modify request for basic parameters like price and quantity...
Definition: Messages.h:4964
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:12683
bool securityId(SecurityIDOptional &value) const noexcept
Security identification as defined by exchange.
Definition: Messages.h:26737
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:10350
ThisType & setCrossPrioritization(CrossPrioritization::Enum value) noexcept
Indicates if one side or the other of a cross order should be prioritized.
Definition: Messages.h:13939
ThisType & setExecutingTraderToNull() noexcept
Definition: Messages.h:8860
bool side(Side::Enum &value) const noexcept
Side of order.
Definition: Messages.h:26673
SchemaTraits Schema
Used template schema.
Definition: Messages.h:2550
StrRef text() const noexcept
Free ASCII format text string.
Definition: Messages.h:16777
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:15709
SeqNum nextSeqNo() const noexcept
The sequence number of the first retransmitted message.
Definition: Messages.h:3805
UInt32 AccountOptional
Optional account mnemonic.
Definition: Fields.h:169
bool actionRequestedFromSessionId(SessionIDOptional &value) const noexcept
Indicates the SessionID that requested the Cancel on behalf.
Definition: Messages.h:12735
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:21825
EstablishReject6(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:2216
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:17314
ThisType & setPosReqId(PosReqID value) noexcept
Unique identifier for the position maintenance request.
Definition: Messages.h:22528
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:15150
ThisType & setPosMaintResult(RejReasonOptional value) noexcept
Identifies reason for rejection.
Definition: Messages.h:24111
bool thresholdAmount(PriceOffsetOptional &value) const noexcept
Used to indicate the minimum acceptable offset between the Strike Price and the Market Price...
Definition: Messages.h:23002
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:12477
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:10163
IntegralConstant< UInt64, 0ULL > NullOrderIDOptional
Null value for an optional OrderIDOptional field.
Definition: Fields.h:2450
SeqNum lastIncomingSeqNo() const noexcept
Indicates the application sequence number of the last application message received by the server from...
Definition: Messages.h:2029
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:15688
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:17860
bool crossedIndicator(CrossedIndicator::Enum &value) const noexcept
Indicates cross order purpose.
Definition: Messages.h:13741
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:22243
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:21661
OutboundBusinessHeader & businessHeader() noexcept
Common header to all outbound business messages.
Definition: Messages.h:10737
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:5603
AllocationInstruction601(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:24529
UInt64 PosMaintRptID
Unique identifier for this position maintenance report message.
Definition: Fields.h:243
UInt32 Firm
Identification of the broker firm.
Definition: Fields.h:175
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:22131
ThisType & setSettlType(SettlType::Enum value) noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:15977
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:11603
ExecutionReportNew200 ThisType
This type alias.
Definition: Messages.h:9392
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:11674
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:4567
bool quoteReqId(QuoteReqIDOptional &value) const noexcept
Unique identifier for quote request.
Definition: Messages.h:20926
static constexpr const Char * className()
Definition: Messages.h:20655
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:21485
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:4778
OutboundBusinessHeader & businessHeader() noexcept
Common header to all outbound business messages.
Definition: Messages.h:13114
const void * tail() const noexcept
Definition: Messages.h:25733
Enum
Identifies the code of reject negotiation.
Definition: Fields.h:1178
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:26010
NewOrderCross106(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:8707
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:23488
Null values definition for optional Price8Optional field.
Definition: Composites.h:281
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:11445
bool expireDate(Timestamp &value) const noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:12429
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:14544
ThisType & setFixedRate(Percentage8 value) noexcept
Interest rate of the forward trade.
Definition: Messages.h:20423
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:3886
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:19189
SecurityDefinitionResponse301 ThisType
This type alias.
Definition: Messages.h:17570
ThisType & setClientAppName(StrRef value)
Application name as informed during certification process.
Definition: Messages.h:322
#define ONIXS_B3_BOE_CONSTEXPR
Definition: Compiler.h:185
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:6964
ThisType & setLegRatioQty(RatioQty value) noexcept
The ratio of quantity for this individual leg relative to the entire multileg security.
Definition: Messages.h:17109
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:9653
NotApplied8 ThisType
This type alias.
Definition: Messages.h:2851
AllocType::Enum allocType() const noexcept
Describes the specific type or purpose of an Allocation message.
Definition: Messages.h:24709
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:1671
Timestamp tradeDate() const noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:13589
bool custodianInfo(CustodianInfo &value) const noexcept
Identifies the custodian.
Definition: Messages.h:7467
ThisType & setMaxFloor(QuantityOptional value) noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:10070
OrderCancelReplaceRequest104 ThisType
This type alias.
Definition: Messages.h:6741
ThisType & setOrigClOrdId(ClOrdIDOptional value) noexcept
Value of origClOrdID field informed from the related request message.
Definition: Messages.h:11054
Firm contraBroker() const noexcept
Broker identifier as assigned by B3 used to indicate the counterparty brokerage firm in a Forward dea...
Definition: Messages.h:19269
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:8922
bool protectionPrice(PriceOptional &value) const noexcept
Conditionally returned on execution reports for Market and Stop Protect orders.
Definition: Messages.h:9755
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:5185
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:23160
OrderMassActionRequest701(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:25844
Negotiate1(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:65
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:26927
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:6498
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:14155
bool minQty(QuantityOptional &value) const noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:7306
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:13239
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:3922
UInt64 MassActionReportIDOptional
Optional unique ID of Order Mass Action Report as assigned by the matching engine.
Definition: Fields.h:289
static constexpr MessageType::Enum messageType() noexcept
Message type = QuoteRequest.
Definition: Messages.h:18290
bool price(Price8Optional &value) const noexcept
Price per share or contract.
Definition: Messages.h:21869
Enum
Used to communicate a reason for a solicited cancel.
Definition: Fields.h:1713
UInt64 SecurityIDOptional
Optional security identification as defined by exchange.
Definition: Fields.h:321
ThisType & setText(StrRef value)
Free ASCII format text string.
Definition: Messages.h:22142
static constexpr MessageType::Enum messageType() noexcept
MessageType.ExecutionReport_Trade.
Definition: Messages.h:13094
ThisType & setPosMaintRptRefId(PosMaintRptIDOptional value) noexcept
Reference to a PosMaintRptID (721) from a previous Position Maintenance Report that is being cancelle...
Definition: Messages.h:22625
ThisType & setStrategyId(StrategyIDOptional value) noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:13971
ThisType & setOrdType(SimpleOrdType::Enum value) noexcept
Order type.
Definition: Messages.h:5325
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:14146
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:15238
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:7376
StrRef text() const noexcept
Free ASCII format text string.
Definition: Messages.h:22113
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:19527
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:7940
ThisType & setAllocTransType(AllocTransType::Enum value) noexcept
Identifies allocation transaction type.
Definition: Messages.h:24696
bool multiLegReportingType(MultiLegReportingType::Enum &value) const noexcept
Used to indicate what an Execution Report represents.
Definition: Messages.h:11157
Enum
Describes the specific type or purpose of an Allocation Report message.
Definition: Fields.h:460
SchemaTraits Schema
Used template schema.
Definition: Messages.h:25781
UInt64 SecurityID
Security identification as defined by exchange.
Definition: Fields.h:315
CancelOnDisconnectType::Enum cancelOnDisconnectType() const noexcept
Criteria used to initiate cancel on disconnect mechanism by the gateway.
Definition: Messages.h:1584
Quote403 ThisType
This type alias.
Definition: Messages.h:20019
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:21511
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:3254
bool expireDate(Timestamp &value) const noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:6330
AllocNoOrdersType::Enum allocNoOrdersType() const noexcept
Indicates how the orders being booked and allocated by an Allocation Instruction. ...
Definition: Messages.h:24731
bool receivedTime(UTCTimestampNanosOptional &value) const noexcept
Time of receipt of related inbound message in the gateway.
Definition: Messages.h:12611
SchemaTraits Schema
Used template schema.
Definition: Messages.h:9389
SimpleModifyOrder101(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:5032
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:16403
ThisType & setTradingSessionId(TradingSessionID::Enum value) noexcept
Identifier for Trading Session.
Definition: Messages.h:16197
ThisType & setAllocAccount(Account value) noexcept
Sub-account mnemonic.
Definition: Messages.h:24924
bool maxFloor(QuantityOptional &value) const noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:6267
SimpleNewOrder message submits a simple new order focused on sent only main parameters with low compl...
Definition: Messages.h:4268
UInt64 PosMaintRptIDOptional
Optional unique identifier for this position maintenance report message.
Definition: Fields.h:251
UInt32 SessionID
Client connection identification on the gateway assigned by B3.
Definition: Fields.h:103
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:24654
Null values definition for optional UTCTimestampNanosOptional field.
Definition: Composites.h:646
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:15829
UInt16 MessageSize
Message length type.
Definition: Aliases.h:29
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:4186
ThisType & setOrigClOrdId(ClOrdIDOptional value) noexcept
ClOrdID which should be replaced.
Definition: Messages.h:7255
static constexpr MessageType::Enum messageType() noexcept
Message type = NotApplied.
Definition: Messages.h:2927
ThisType & setCount(MessageCounter value) noexcept
Number of messages to be retransmitted.
Definition: Messages.h:3834
Firm contraBroker() const noexcept
Identifies the contra broker firm.
Definition: Messages.h:13548
Timestamp tradeDate() const noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:9788
Sides sides(Sides::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:22085
PosReqID posReqId() const noexcept
Unique identifier for the position maintenance request.
Definition: Messages.h:22519
SimpleNewOrder100(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:4336
IntegralConstant< UInt8, 0 > NullUint8EnumEncoding
Null value for an optional Uint8EnumEncoding field.
Definition: Fields.h:2540
ThisType & setMinQty(QuantityOptional value) noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:7315
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:12765
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:9123
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:7032
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:25607
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:21132
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:12009
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:7748
OrderID secondaryOrderId() const noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:10810
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:25656
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:21453
Enum
Indicates reason of cancelation, if available.
Definition: Fields.h:1760
bool tradeId(TradeIDOptional &value) const noexcept
The unique ID assigned to the trade entity once it is received or matched by the exchange or central ...
Definition: Messages.h:23881
NewOrderSingle102(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:5748
ThisType & setTimeInForce(SimpleTimeInForce::Enum value) noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:5347
ThisType & setMaxFloor(QuantityOptional value) noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:7346
NotApplied8(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:2900
ThisType & setMarketSegmentReceivedTimeToNull() noexcept
Definition: Messages.h:9741
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:19403
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:19494
bool legSide(Side::Enum &value) const noexcept
The side of this individual leg (multileg security).
Definition: Messages.h:17121
SecurityDefinitionResponse301(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:17608
StrRef text() const noexcept
Free ASCII format text string.
Definition: Messages.h:26819
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:4854
Enum
Describes the specific type or purpose of an Allocation message.
Definition: Fields.h:482
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:23044
Enum
Used to indicate what an Execution Report represents.
Definition: Fields.h:1839
static constexpr MessageType::Enum messageType() noexcept
Message type = NegotiateResponse.
Definition: Messages.h:674
BusinessMessageReject206 ThisType
This type alias.
Definition: Messages.h:16567
static constexpr MessageType::Enum messageType() noexcept
MessageType.ExecutionReport_Forward.
Definition: Messages.h:15564
NegotiateResponse2(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:607
ThisType & setQuoteReqId(QuoteReqID value) noexcept
Unique identifier for quote request.
Definition: Messages.h:18370
bool crossId(CrossIDOptional &value) const noexcept
ID of electronically submitted cross order by the institution (if in response to a cross order)...
Definition: Messages.h:14963
UInt64 QuoteReqID
Unique identifier for quote request.
Definition: Fields.h:363
Null values definition for optional CustodianInfo field.
Definition: Composites.h:1189
static constexpr MessageType::Enum messageType() noexcept
Message type = QuoteCancel.
Definition: Messages.h:20854
static constexpr const Char * className()
Definition: Messages.h:25064
ThisType & setRetransmitRejectCode(RetransmitRejectCode::Enum value) noexcept
Identifies the code of reject retransmission.
Definition: Messages.h:4124
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:15160
const InboundBusinessHeader & businessHeader() const noexcept
Message type = NewOrderSingle.
Definition: Messages.h:5826
bool currentSessionVerId(SessionVerIDOptional &value) const noexcept
The current sessionVerID informed at the first Negotiate message for that specific session...
Definition: Messages.h:1199
ThisType & setTradeId(TradeID value) noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:13537
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:17502
ThisType & setLastPx(Price value) noexcept
Price of last fill.
Definition: Messages.h:15787
ThisType & setSelfTradePreventionInstruction(SelfTradePreventionInstruction::Enum value) noexcept
Indicates which order should be cancelled due to Self- Trade Prevention.
Definition: Messages.h:7011
static constexpr const Char * className()
Definition: Messages.h:5638
UInt8 OrdTagID
Identifies the order tag identification.
Definition: Fields.h:295
ThisType & setClearingBusinessDate(Timestamp value) noexcept
The &#39;Clearing Business Date&#39; referred to by this request.
Definition: Messages.h:23983
ExecutionReportForward205(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:15526
bool secondaryExecId(ExecIDOptional &value) const noexcept
Unique identifier present in all messages associated with a spread transaction.
Definition: Messages.h:13645
ThisType & setEnteringFirm(Firm value) noexcept
Identifies the broker firm that will enter orders.
Definition: Messages.h:221
PositionMaintenanceCancelRequest501(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:22423
ThisType & setQuoteId(QuoteIDOptional value) noexcept
Unique identifier for quote.
Definition: Messages.h:20965
ThisType & setEnteringFirm(FirmOptional value) noexcept
Identifies the broker firm that will enter orders.
Definition: Messages.h:8560
SeqNum fromSeqNo() const noexcept
The first applied sequence number.
Definition: Messages.h:3495
ExecType::Enum execType() const noexcept
Describes the action that triggered this specific Execution Report - see the OrdStatus (39) tag for t...
Definition: Messages.h:13436
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:1698
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:18765
Quantity cumQty() const noexcept
Total number of shares or contracts filled.
Definition: Messages.h:12095
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:9592
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:2440
BusinessMessageReject message can reject an application-level message which fulfills session level ru...
Definition: Messages.h:16559
SbeGroup< SidesEntry, GroupSizeEncoding, MessageSize > Sides
Repeating group containing SidesEntry entries.
Definition: Messages.h:21520
ThisType & setNextSeqNo(SeqNum value) noexcept
The next application sequence number to be produced by the client.
Definition: Messages.h:3214
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:25698
bool maxSweepQty(QuantityOptional &value) const noexcept
Maximum sweep quantity.
Definition: Messages.h:9054
ExecutionReportReject204(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:14358
ThisType & setSecondaryExecId(ExecIDOptional value) noexcept
Unique identifier present in all messages associated with a spread transaction.
Definition: Messages.h:16073
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:4579
ThisType & setSessionVerId(SessionVerID value) noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:1101
SessionVerID sessionVerId() const noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:1088
ThisType & setKeepAliveInterval(DeltaInMillis value) noexcept
Longest time in milliseconds the initiator should remain silent before sending Sequence message...
Definition: Messages.h:1993
bool strategyId(StrategyIDOptional &value) const noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:11543
OrderID orderId() const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:12223
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:5275
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:22572
bool execRefId(ExecIDOptional &value) const noexcept
Optionally sent when reporting a trade bust.
Definition: Messages.h:13679
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:2468
ThisType & setNextSeqNo(SeqNum value) noexcept
The next application sequence number to be produced by the gateway.
Definition: Messages.h:2015
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:18798
ThisType & setOrdType(OrdType::Enum value) noexcept
Order type.
Definition: Messages.h:14738
static constexpr MessageType::Enum messageType() noexcept
Message type = TermoQuote.
Definition: Messages.h:20095
static constexpr const Char * className()
Definition: Messages.h:9240
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:19505
RetransmitReject14(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:4009
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:12804
UInt64 QuoteIDOptional
Optional unique identifier for quote.
Definition: Fields.h:357
NegotiateResponse2(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:622
ThisType & setCrossedIndicator(CrossedIndicator::Enum value) noexcept
Indicates cross order purpose.
Definition: Messages.h:15005
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:14224
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:7980
const void * tail() const noexcept
Definition: Messages.h:6635
bool timeInForce(TimeInForce::Enum &value) const noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:7104
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:11279
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:19808
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:8281
ThisType & setStrategyId(StrategyIDOptional value) noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:12714
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:26890
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:10451
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:20579
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:18208
bool routingInstruction(RoutingInstruction::Enum &value) const noexcept
Indicates additional order instruction.
Definition: Messages.h:5360
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for mass cancel on behalf purposes.
Definition: Messages.h:26789
ThisType & setTradeDate(Timestamp value) noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:24873
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:3947
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:11270
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:4748
ThisType & setCumQty(Quantity value) noexcept
Total number of shares or contracts filled.
Definition: Messages.h:13401
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:22560
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:18101
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:23787
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:938
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:3848
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:23775
bool crossedIndicator(CrossedIndicator::Enum &value) const noexcept
Indicates cross order purpose.
Definition: Messages.h:14994
Self trade prevention investor identification is composed of the prefix and document.
Definition: Composites.h:1805
SchemaTraits Schema
Used template schema.
Definition: Messages.h:2189
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:360
bool secondaryExecId(ExecIDOptional &value) const noexcept
Unique identifier present in all messages associated with a spread transaction.
Definition: Messages.h:16060
ThisType & setExpireDate(Timestamp value) noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:11250
ThisType & setCrossType(CrossType::Enum value) noexcept
Type of cross being submitted to a market.
Definition: Messages.h:10225
const void * tail() const noexcept
Definition: Messages.h:4892
ThisType & setQuoteId(QuoteID value) noexcept
Unique identifier for quote.
Definition: Messages.h:20195
#define ONIXS_B3_BOE_NODISCARD
Definition: Compiler.h:191
ThisType & setTimestamp(UTCTimestampNanos value) noexcept
Time of request.
Definition: Messages.h:188
ThisType & setSecurityReqId(SecurityReqRespID value) noexcept
Unique ID of a Security Definition Request.
Definition: Messages.h:17303
ExecutionReportCancel202(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:11901
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:21185
SchemaTraits Schema
Used template schema.
Definition: Messages.h:1823
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:4785
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:25096
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:26290
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:22105
Enum
Used to identify the type of quantity.
Definition: Fields.h:644
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:7654
const InboundBusinessHeader & businessHeader() const noexcept
Message type = OrderCancelReplaceRequest.
Definition: Messages.h:6828
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:9948
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:23228
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:24996
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:18182
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:14092
ThisType & setExpireDate(Timestamp value) noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:9928
EstablishReject6(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:2252
TerminationCode::Enum terminationCode() const noexcept
Identifies the code of termination.
Definition: Messages.h:2689
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:2768
ThisType & setTimeInForce(TimeInForce::Enum value) noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:6111
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:7950
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:1657
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:2761
bool crossType(CrossType::Enum &value) const noexcept
Type of cross being submitted to a market.
Definition: Messages.h:13893
Header used for inbound business messages.
Definition: Composites.h:1240
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:15255
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:4812
IntegralConstant< UInt64, 0ULL > NullBusinessRejectRefID
Null value for an optional BusinessRejectRefID field.
Definition: Fields.h:2474
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:8913
bool crossType(CrossType::Enum &value) const noexcept
Type of cross being submitted to a market.
Definition: Messages.h:10215
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:16859
OrderMassActionRequest701(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:25822
RetransmitRejectCode::Enum retransmitRejectCode() const noexcept
Identifies the code of reject retransmission.
Definition: Messages.h:4114
ThisType & setOrderId(OrderID value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:11032
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:18329
ThisType & setSecurityResponseId(SecurityReqRespID value) noexcept
Unique ID of a Security Definition message.
Definition: Messages.h:17839
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:6399
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:13359
Custodian information is required for going private offer.
Definition: Composites.h:1075
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:9193
ThisType & setSecondaryOrderId(OrderID value) noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:12043
OrderCancelReplaceRequest104(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:6765
OrdStatus::Enum ordStatus() const noexcept
Identifies current status of order.
Definition: Messages.h:13143
bool minQty(QuantityOptional &value) const noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:14902
Negotiate1 ThisType
This type alias.
Definition: Messages.h:41
Firm contraBroker() const noexcept
Identifies the contra broker firm.
Definition: Messages.h:15904
ThisType & setRequestTimestamp(UTCTimestampNanos value) noexcept
Matches Negotiate timestamp.
Definition: Messages.h:2337
ThisType & setQuoteReqIdToNull() noexcept
Definition: Messages.h:20945
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:6490
ThisType & setTradeId(TradeIDOptional value) noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:19248
SecurityDefinitionRequest300(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:17249
ThisType & setExpireDate(Timestamp value) noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:6349
static constexpr const Char * className()
Definition: Messages.h:904
ThisType & setAccountType(AccountType::Enum value) noexcept
Type of account associated with an order.
Definition: Messages.h:7407
ThisType & setRoutingInstruction(RoutingInstruction::Enum value) noexcept
Indicates additional order instruction.
Definition: Messages.h:5371
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:8522
ThisType & setOrderId(OrderIDOptional value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:5452
SecurityDefinitionRequest300(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:17227
RatioQty legRatioQty() const noexcept
The ratio of quantity for this individual leg relative to the entire multileg security.
Definition: Messages.h:17099
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:12643
EstablishmentReject message is sent when an Establish message is rejected by B3 informing the reason ...
Definition: Messages.h:2184
Sequence9(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:3126
IntegralConstant< UInt64, 0ULL > NullCrossIDOptional
Null value for an optional CrossIDOptional field.
Definition: Fields.h:2504
MessageCounter count() const noexcept
Maximum number of messages to be retransmitted.
Definition: Messages.h:3516
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:16769
bool tradeId(TradeIDOptional &value) const noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:21743
StrRef text() const noexcept
Free ASCII format text string.
Definition: Messages.h:19739
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:24263
bool tradeId(TradeIDOptional &value) const noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:18411
SimpleOrdType::Enum ordType() const noexcept
Order type.
Definition: Messages.h:5315
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:20380
ThisType & setPrice(PriceOptional value) noexcept
Price per share or contract.
Definition: Messages.h:7197
Percentage8 fixedRate() const noexcept
Describes the interest to be paid by the forward buyer and received by the forward seller...
Definition: Messages.h:18654
ThisType & setNegotiationRejectCode(NegotiationRejectCode::Enum value) noexcept
Identifies the code of reject negotiation.
Definition: Messages.h:1185
ThisType & setTradeDate(Timestamp value) noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:16008
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:24371
bool daysToSettlement(DaysToSettlementOptional &value) const noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:22023
The QuoteStatusReport message is to inform the current status of forward acceptance.
Definition: Messages.h:19013
const OutboundBusinessHeader & businessHeader() const noexcept
Message type = BusinessMessageReject.
Definition: Messages.h:16654
SidesEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:21370
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:11686
const InboundBusinessHeader & businessHeader() const noexcept
Message type = SimpleNewOrder.
Definition: Messages.h:4363
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:3587
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:25629
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:15214
PositionMaintenanceRequest502(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:22872
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:23035
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:26236
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:22183
bool protectionPrice(PriceOptional &value) const noexcept
Conditionally returned on execution reports for Market and Stop Protect orders.
Definition: Messages.h:11077
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:11659
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:5611
ThisType & setMaxSweepQty(QuantityOptional value) noexcept
Maximum sweep quantity.
Definition: Messages.h:9063
ThisType & setOrigClOrdId(ClOrdIDOptional value) noexcept
Value of origClOrdID field informed from the related request message.
Definition: Messages.h:12254
Boolean::Enum workingIndicator() const noexcept
Indicates if an order has been triggered and is available for trading.
Definition: Messages.h:9811
MassActionType::Enum massActionType() const noexcept
Specifies the type of action requested.
Definition: Messages.h:25889
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:25721
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:8225
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:21938
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:12166
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:13227
IntegralConstant< UInt32, 0 > NullFirmOptional
Null value for an optional FirmOptional field.
Definition: Fields.h:2432
ThisType & setOrdType(OrdType::Enum value) noexcept
Order type.
Definition: Messages.h:7093
ThisType & setAllocId(AllocID value) noexcept
Unique identifier for this allocation instruction message.
Definition: Messages.h:24634
Unique ID for all matches that occur as a result of a implied event.
Definition: Composites.h:1946
bool daysToSettlement(DaysToSettlementOptional &value) const noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:19659
UTCTimestampNanos requestTimestamp() const noexcept
Matches Negotiate timestamp.
Definition: Messages.h:734
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:6030
ThisType & setQuoteId(QuoteID value) noexcept
Unique identifier for quote.
Definition: Messages.h:19226
Enum
Identifier for the instrument status.
Definition: Fields.h:2103
ThisType & setTimeInForce(TimeInForce::Enum value) noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:7113
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:20540
QuoteStatus::Enum quoteStatus() const noexcept
Identifies the status of the quote acknowledgement.
Definition: Messages.h:19310
ThisType & setExecId(ExecID value) noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:15809
ThisType & setMaxFloor(QuantityOptional value) noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:14942
OrderCancelReplaceRequest104(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:6750
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:22214
ThisType & setRefMsgType(MessageType::Enum value) noexcept
MsgType of the FIX message being referenced.
Definition: Messages.h:16681
ThisType & setLastQty(Quantity value) noexcept
Quantity of shares bought/sold on the last fill.
Definition: Messages.h:13297
ExecutionReportForward205(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:15537
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:9497
ThisType & setCodTimeoutWindow(DeltaInMillis value) noexcept
Gateway will not trigger CoD if the customer reconnects within the timeout window (milliseconds) whic...
Definition: Messages.h:1622
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:12652
RetransmitRequest12(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:3425
ThisType & setShortQty(QuantityOptional value) noexcept
Short Quantity.
Definition: Messages.h:23565
ThisType & setStrategyId(StrategyIDOptional value) noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:7538
static constexpr MessageType::Enum messageType() noexcept
Message type = OrderMassActionReport.
Definition: Messages.h:26404
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:26001
ThisType & setContraryInstructionIndicator(Boolean::Enum value) noexcept
Used to indicate when a contrary instruction for exercise or abandonment is being submitted: The exer...
Definition: Messages.h:23149
bool executeUnderlyingTrade(ExecuteUnderlyingTrade::Enum &value) const noexcept
Specifies if a simultaneous trade of the underlying is to be performed.Required to indicate Termo Vis...
Definition: Messages.h:19607
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:19820
static constexpr MessageType::Enum messageType() noexcept
Message type = Terminate.
Definition: Messages.h:2629
ThisType & setStopPx(PriceOptional value) noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:12530
Sides sides(Sides::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:9100
UInt32 FirmOptional
Optional identification of the broker firm.
Definition: Fields.h:181
ThisType & setEnteringFirm(FirmOptional value) noexcept
Identifies the broker firm that will enter orders.
Definition: Messages.h:1154
bool expireDate(Timestamp &value) const noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:7428
IntegralConstant< UInt8, 0 > NullOrdTagID
Null value for an optional OrdTagID field.
Definition: Fields.h:2486
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:833
static constexpr MessageType::Enum messageType() noexcept
Message type = RetransmitRequest.
Definition: Messages.h:3441
TradeID tradeId() const noexcept
The unique ID assigned to the trade entity once it is received or matched by the exchange or central ...
Definition: Messages.h:24831
NegotiateResponse2(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:636
SessionID sessionId() const noexcept
Message type = Establish.
Definition: Messages.h:1465
Entries::Size Size
Number of entries in the group.
Definition: SbeMessage.h:674
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:846
QuoteStatusReport402 ThisType
This type alias.
Definition: Messages.h:19021
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:449
The SecurityDefinitioresponse message is sent in response to an attempt to create a new security defi...
Definition: Messages.h:17562
ThisType & setCumQty(Quantity value) noexcept
Total number of shares or contracts filled.
Definition: Messages.h:12104
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:6042
The QuoteCancel message is used to cancel a previous QuoteRequest message.
Definition: Messages.h:20770
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:26137
AllocationInstruction601(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:24580
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:8207
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:14201
bool securityId(SecurityIDOptional &value) const noexcept
Security identification as defined by exchange.
Definition: Messages.h:26094
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:21804
OrderMassActionReport702(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:26377
bool minQty(QuantityOptional &value) const noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:12550
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:22510
StrRef symbol() const noexcept
B3 requires that this field is properly set.
Definition: Messages.h:17806
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:2154
static constexpr const Char * className()
Definition: Messages.h:11735
IntegralConstant< UInt32, 0 > NullTradeIDOptional
Null value for an optional TradeIDOptional field.
Definition: Fields.h:2510
bool orderId(OrderIDOptional &value) const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:7217
ThisType & setFixedRate(Percentage8Optional value) noexcept
Interest rate of the forward trade.
Definition: Messages.h:19583
ThisType & setSymbol(StrRef value) noexcept
B3 requires that this field is properly set.
Definition: Messages.h:17818
ThisType & setTimeInForce(TimeInForce::Enum value) noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:14758
ThisType & setMassActionReportId(MassActionReportIDOptional value) noexcept
Unique ID of Order Mass Action Report as assigned by the matching engine.
Definition: Messages.h:12367
OrdType::Enum ordType() const noexcept
Order type.
Definition: Messages.h:9868
const void * tail() const noexcept
Definition: Messages.h:3934
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:20146
Null values definition for optional PriceOffsetOptional field.
Definition: Composites.h:349
ThisType & setAllocType(AllocType::Enum value) noexcept
Describes the specific type or purpose of an Allocation message.
Definition: Messages.h:24719
bool crossPrioritization(CrossPrioritization::Enum &value) const noexcept
Indicates if one side or the other of a cross order should be prioritized.
Definition: Messages.h:13926
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:4193
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:14491
Enum
Identifies the type of position transaction.
Definition: Fields.h:868
TimeInForce::Enum timeInForce() const noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:9888
IntegralConstant< UInt64, 0ULL > NullClOrdIDOptional
Null value for an optional ClOrdIDOptional field.
Definition: Fields.h:2390
IntegralConstant< UInt16, 0 > NullUint16EnumEncoding
Null value for an optional Uint16EnumEncoding field.
Definition: Fields.h:2546
static constexpr const Char * className()
Definition: Messages.h:2779
ThisType & setSelfTradePreventionInstruction(SelfTradePreventionInstruction::Enum value) noexcept
Indicates which order should be cancelled due to Self- Trade Prevention.
Definition: Messages.h:6009
ThisType & setPosType(PosType::Enum value) noexcept
Used to identify the type of quantity.
Definition: Messages.h:23516
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:19485
UInt32 SeqNumOptional
Optional sequence number of a given SessionID/SessionVerID.
Definition: Fields.h:133
SchemaTraits Schema
Used template schema.
Definition: Messages.h:13015
ThisType & setMarketSegmentReceivedTime(UTCTimestampNanosOptional value) noexcept
Time of receipt of related inbound message in the market segment path.
Definition: Messages.h:9731
ThisType & setRoutingInstructionToNull() noexcept
Definition: Messages.h:6144
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:7507
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:12063
ThisType & setOrderId(OrderID value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:12232
StrRef executingTrader() const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:21069
ThisType & setOrigClOrdId(ClOrdIDOptional value) noexcept
Value of origClOrdID field informed from the related request message.
Definition: Messages.h:14680
IntegralConstant< UInt64, 0ULL > NullQuoteIDOptional
Null value for an optional QuoteIDOptional field.
Definition: Fields.h:2516
ThisType & setOrdType(SimpleOrdType::Enum value) noexcept
Order type.
Definition: Messages.h:4629
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:25042
ThisType & setThresholdAmount(PriceOffsetOptional value) noexcept
Used to indicate the minimum acceptable offset between the Strike Price and the Market Price...
Definition: Messages.h:23014
bool origPosReqRefId(PosReqIDOptional &value) const noexcept
Reference to the PosReqID (710) of a previous maintenance request that is being cancelled.
Definition: Messages.h:22581
ThisType & setQuoteReqId(QuoteReqIDOptional value) noexcept
Unique identifier for quote request.
Definition: Messages.h:20936
OrderCancelRequest105(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:7893
Sides sides(Sides::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:9111
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:9164
ExecutionReportReject204(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:14380
NewOrderCross106 ThisType
This type alias.
Definition: Messages.h:8441
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:18353
static constexpr Boolean::Enum privateQuote() noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:19644
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:17727
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:18836
bool minQty(QuantityOptional &value) const noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:11352
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:2411
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:9538
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:20893
OrderID orderId() const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:9624
ThisType & setAccountToNull() noexcept
Definition: Messages.h:21014
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:13132
bool executeUnderlyingTrade(ExecuteUnderlyingTrade::Enum &value) const noexcept
Specifies if a simultaneous trade of the underlying is to be performed.Required to indicate Termo Vis...
Definition: Messages.h:20437
ThisType & setIndividualAllocId(AllocID value) noexcept
Unique identifier for a specific NoAllocs (78) repeating group instance (e.g.
Definition: Messages.h:24904
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:20266
NewOrderCross106(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:8693
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:2109
ThisType & setPrice(Price8 value) noexcept
Price per share or contract.
Definition: Messages.h:18494
UInt16 LocalMktDateOptional
Local calendar date: days since Unix epoch (January 1st, 1970).
Definition: Fields.h:157
ThisType & setThresholdAmount(PriceOffsetOptional value) noexcept
Used to indicate the minimum acceptable offset between the Strike Price and the Market Price...
Definition: Messages.h:24008
static constexpr const Char * className()
Definition: Messages.h:19865
ThisType & setOrdStatus(OrdStatus::Enum value) noexcept
Identifies current status of order.
Definition: Messages.h:13152
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:23074
AllocID individualAllocId() const noexcept
Unique identifier for a specific NoAllocs (78) repeating group instance (e.g.
Definition: Messages.h:24894
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:11454
Enum
Type of Account associated with an order.
Definition: Fields.h:1910
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:5902
Quantity cumQty() const noexcept
Total number of shares or contracts filled.
Definition: Messages.h:13392
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:19731
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:4902
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:11642
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:25746
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:4499
bool tradeDate(Timestamp &value) const noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:25518
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:10436
DaysToSettlement daysToSettlement() const noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:20488
ThisType & setReceivedTime(UTCTimestampNanosOptional value) noexcept
Time of receipt of related inbound message in the gateway.
Definition: Messages.h:10133
bool posMaintResult(RejReasonOptional &value) const noexcept
Identifies reason for rejection.
Definition: Messages.h:24101
Execution Report – Trade/Trade Bust message is sent with order fills that were traded and processed ...
Definition: Messages.h:13010
#define ONIXS_B3_BOE_MESSAGING_NAMESPACE_BEGIN
Definition: ABI.h:140
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:2490
OrdStatus::Enum ordStatus() const noexcept
Identifies current status of order.
Definition: Messages.h:9517
NotApplied8(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:2911
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:10406
PositionMaintenanceRequest502(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:22894
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:25691
Timestamp tradeDate() const noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:15998
UTCTimestampNanos requestTimestamp() const noexcept
Matches Negotiate timestamp.
Definition: Messages.h:4093
UInt64 QuoteReqIDOptional
Optional unique identifier for quote request.
Definition: Fields.h:369
ThisType & setClientIP(StrRef value)
Source IP from client system.
Definition: Messages.h:311
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:7568
RetransmitRequest12(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:3403
StrRef executingTrader() const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:18628
ThisType & setQuoteStatusResponseToToNull() noexcept
Definition: Messages.h:19354
Int32 StrategyIDOptional
Optional unique identification of a client-assigned strategy.
Definition: Fields.h:387
ThisType & setMinQty(QuantityOptional value) noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:6246
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:13782
SchemaTraits Schema
Used template schema.
Definition: Messages.h:3114
RetransmitReject14(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:4034
MessageType::Enum refMsgType() const noexcept
MsgType of the FIX message being referenced.
Definition: Messages.h:16672
OrderMassActionRequest701(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:25793
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:20664
static constexpr MessageType::Enum messageType() noexcept
Message type = Establish.
Definition: Messages.h:1454
SchemaTraits Schema
Used template schema.
Definition: Messages.h:6738
bool custodianInfo(CustodianInfo &value) const noexcept
Identifies the custodian.
Definition: Messages.h:6369
Quantity longQty() const noexcept
Used to identify the type of quantity.
Definition: Messages.h:23193
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:14607
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:872
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:10904
static constexpr MessageType::Enum messageType() noexcept
MessageType.ExecutionReport_Modify.
Definition: Messages.h:10717
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:15738
LegsEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:17035
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:14709
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:2093
bool execRefId(ExecIDOptional &value) const noexcept
Optionally sent when reporting a trade bust.
Definition: Messages.h:16094
ThisType & setSecondaryOrderId(OrderIDOptional value) noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:14515
SidesEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:18067
AllocReportID allocReportId() const noexcept
Unique identifier for this message.
Definition: Messages.h:25358
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:23355
ThisType & setOrderId(OrderIDOptional value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:14649
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:394
ThisType & setQuoteRequestRejectReason(RejReasonOptional value) noexcept
Reason Quote was rejected.
Definition: Messages.h:21632
EstablishReject6(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:2230
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:8289
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:5295
OrdType::Enum ordType() const noexcept
Order type.
Definition: Messages.h:12388
UInt64 ExecIDOptional
Optional unique identifier of execution message as assigned by exchange.
Definition: Fields.h:207
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:9616
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:4521
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:14033
QuoteStatusReport402(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:19070
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:25670
ExecID execId() const noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:15799
bool executingTrader(StrRef &value) const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:8840
ThisType & setQuoteId(QuoteIDOptional value) noexcept
Unique identifier for quote.
Definition: Messages.h:18390
ThisType & setCredentials(StrRef value)
Credentials to identify/authenticate the client. The format is a JSON with the following data: { "aut...
Definition: Messages.h:1642
NewOrderSingle message is used to enter an order in the system; the behavior of an order can be affec...
Definition: Messages.h:5731
Sides sides(Sides::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:22074
bool fixedRate(Percentage8Optional &value) const noexcept
Describes the interest to be paid by the forward buyer and received by the forward seller...
Definition: Messages.h:16129
PositionMaintenanceCancelRequest501(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:22474
static constexpr OrdStatus::Enum ordStatus() noexcept
Identifies current status of order.
Definition: Messages.h:14446
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:15270
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:16383
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:25955
const void * tail() const noexcept
Definition: Messages.h:21238
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:21363
SchemaTraits Schema
Used template schema.
Definition: Messages.h:15485
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:11744
IntegralConstant< UInt64, 0ULL > NullSecurityIDOptional
Null value for an optional SecurityIDOptional field.
Definition: Fields.h:2498
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:8460
const void * tail() const noexcept
Definition: Messages.h:3066
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:11611
static constexpr MessageType::Enum messageType() noexcept
Message type = EstablishReject.
Definition: Messages.h:2268
Retransmission13(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:3686
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:19703
BidirectionalBusinessHeader & businessHeader() noexcept
Common header to all bidirectional business messages.
Definition: Messages.h:20875
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:16322
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:18341
Terminate7(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:2562
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:18606
UInt64 SessionVerID
Session version identification: unique identification of a sequence of messages to be transmitted to ...
Definition: Fields.h:115
ThisType & setTradeDate(Timestamp value) noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:25537
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:6855
Enum
Identifies the code of reject retransmission.
Definition: Fields.h:1376
PositionMaintenanceReport503(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:23669
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:7666
const void * tail() const noexcept
Definition: Messages.h:1327
Null values definition for optional InvestorID field.
Definition: Composites.h:1895
After negotiation level is complete, the client must send an Establish message to start assigning seq...
Definition: Messages.h:1370
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:20286
bool routingInstruction(RoutingInstruction::Enum &value) const noexcept
Indicates additional order instruction.
Definition: Messages.h:4664
ThisType & setExecuteUnderlyingTrade(ExecuteUnderlyingTrade::Enum value) noexcept
Specifies if a simultaneous trade of the underlying is to be performed.Required to indicate Termo Vis...
Definition: Messages.h:19620
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:9957
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:17872
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:374
SessionID sessionId() const noexcept
Message type = Retransmission.
Definition: Messages.h:3764
SimpleTimeInForce::Enum timeInForce() const noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:4641
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:20606
bool crossPrioritization(CrossPrioritization::Enum &value) const noexcept
Indicates if one side or the other of a cross order should be prioritized.
Definition: Messages.h:10248
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:22265
ThisType & setMinQty(QuantityOptional value) noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:12559
ThisType & setCustodianInfo(CustodianInfo value) noexcept
Identifies the custodian.
Definition: Messages.h:6378
Sides sides(Sides::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:18745
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:8199
ThisType & setLastPx(Price value) noexcept
Price of last fill.
Definition: Messages.h:13317
static constexpr Boolean::Enum privateQuote() noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:21094
ExecutionReportReject204(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:14369
ThisType & setDaysToSettlement(DaysToSettlementOptional value) noexcept
Deadline for completing the forward deal.
Definition: Messages.h:22036
static constexpr QuoteCancelType::Enum quoteCancelType() noexcept
Identifies the type of quote cancel.
Definition: Messages.h:20986
ThisType & setOrigClOrdId(ClOrdIDOptional value) noexcept
ClOrdID which should be cancelled.
Definition: Messages.h:8050
ThisType & setOrderQty(QuantityOptional value) noexcept
Quantity ordered.
Definition: Messages.h:14820
IntegralConstant< UInt64, 0ULL > NullExecIDOptional
Null value for an optional ExecIDOptional field.
Definition: Fields.h:2444
QuoteID quoteId() const noexcept
Unique identifier for quote.
Definition: Messages.h:20186
SessionVerID sessionVerId() const noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:710
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:17926
Enum
Identifier for the instrument group phase.
Definition: Fields.h:2066
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:6837
ThisType & setClOrdId(ClOrdIDOptional value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:15644
static constexpr Boolean::Enum privateQuote() noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:20474
bool quoteStatusResponseTo(QuoteStatusResponseTo::Enum &value) const noexcept
Identifies the type of request that a Quote Status Report is in response to.
Definition: Messages.h:19332
IntegralConstant< Char, '\x0'> NullChar
Null value for an optional Char field.
Definition: Fields.h:32
static constexpr const Char * className()
Definition: Messages.h:25712
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:16851
SessionID sessionId() const noexcept
Message type = EstablishReject.
Definition: Messages.h:2279
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:427
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:8123
ThisType & setMaxFloor(QuantityOptional value) noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:12590
UInt64 SessionVerIDOptional
Optional session version identification: unique identification of a sequence of messages to be transm...
Definition: Fields.h:121
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:7056
Retransmission13(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:3726
ThisType & setOrderQty(QuantityOptional value) noexcept
Quantity ordered.
Definition: Messages.h:21908
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:6307
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:24645
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:18616
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:12846
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:1756
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:2813
StrRef senderLocation() const noexcept
Side of order.
Definition: Messages.h:24785
ThisType & setAsset(StrRef value) noexcept
Asset associated with the security, such as DOL, BGI, OZ1, WDL, CNI, etc.
Definition: Messages.h:26714
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:15188
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:7992
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:2980
Boolean::Enum mmProtectionReset() const noexcept
Resets Market Protections.
Definition: Messages.h:5110
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:11694
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:11703
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:23280
bool massActionScope(MassActionScope::Enum &value) const noexcept
Specifies the scope of the action.
Definition: Messages.h:25912
ThisType & setFromSeqNo(SeqNum value) noexcept
The first applied sequence number.
Definition: Messages.h:3504
ThisType & setTradingSessionSubId(TradingSessionSubID::Enum value) noexcept
Identifier for the instrument group phase.
Definition: Messages.h:13838
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:1285
ThisType & setCount(MessageCounter value) noexcept
Maximum number of messages to be retransmitted.
Definition: Messages.h:3526
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:5619
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:23587
static constexpr MessageType::Enum messageType() noexcept
Message type = OrderCancelReplaceRequest.
Definition: Messages.h:6817
IntegralConstant< UInt64, 0ULL > NullSessionVerIDOptional
Null value for an optional SessionVerIDOptional field.
Definition: Fields.h:2402
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:7725
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:19374
SessionID sessionId() const noexcept
Message type = Negotiate.
Definition: Messages.h:128
std::basic_string_view< Char > StrRef
Definition: StrRef.h:46
SettlType::Enum settlType() const noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:18506
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:5932
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:16368
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:5156
ThisType & setCurrentSessionVerId(SessionVerIDOptional value) noexcept
The current sessionVerID informed at the first Negotiate message for that specific session...
Definition: Messages.h:1211
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:16284
NewOrderSingle102(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:5788
NotApplied8(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:2875
BusinessMessageReject206(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:16616
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:9149
SchemaTraits Schema
Used template schema.
Definition: Messages.h:3982
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:9249
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:18060
QuoteStatusReport402(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:19045
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:20158
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:19794
ThisType & setFixedRate(Percentage8Optional value) noexcept
Describes the interest to be paid by the forward buyer and received by the forward seller...
Definition: Messages.h:16144
ThisType & setSecondaryOrderId(OrderID value) noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:15677
MassActionReportID massActionReportId() const noexcept
Unique ID of Order Mass Action Report as assigned by the matching engine.
Definition: Messages.h:26511
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:6071
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:11573
PositionMaintenanceReport503(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:23644
constexpr std::enable_if< MaxMessageSizeTraits< Message >::UseCustomValue, MessageSize >::type getMaxMessageSize(UInt8)
Calculates the buffer size for a message with the given number of repeating group items...
static constexpr MessageType::Enum messageType() noexcept
Message type = BusinessMessageReject.
Definition: Messages.h:16643
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:8636
bool execRestatementReason(ExecRestatementReasonValidForMassCancel::Enum &value) const noexcept
Used to communicate event type which triggers the Order Mass Action Request.
Definition: Messages.h:26611
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:21057
Quote403(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:20068
SimpleModifyOrder101 ThisType
This type alias.
Definition: Messages.h:4972
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:9583
ThisType & setQuantity(Quantity value) noexcept
Overall/total quantity (e.g. number of shares).
Definition: Messages.h:24763
const void * tail() const noexcept
Definition: Messages.h:4225
The NegotiationResponse message is sent when a Negotiate message from the client is accepted by B3...
Definition: Messages.h:590
bool quoteId(QuoteIDOptional &value) const noexcept
Unique identifier for quote.
Definition: Messages.h:21713
ThisType & setMassActionResponse(MassActionResponse::Enum value) noexcept
Specifies the action taken by matching engine when it receives the Order Mass Action Request...
Definition: Messages.h:26564
bool price(PriceOptional &value) const noexcept
Price per share or contract.
Definition: Messages.h:11291
IntegralConstant< Int32, 0 > NullStrategyIDOptional
Null value for an optional StrategyIDOptional field.
Definition: Fields.h:2534
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:25073
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:10755
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:24955
static constexpr Boolean::Enum privateQuote() noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:18681
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:16890
ThisType & setActionRequestedFromSessionIdToNull() noexcept
Definition: Messages.h:12754
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:21202
bool daysToSettlement(DaysToSettlementOptional &value) const noexcept
Deadline for completing the forward deal.
Definition: Messages.h:16022
ExecutionReportCancel202(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:11923
ExecutionReportNew200(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:9401
Negotiate1(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:79
UTCTimestampNanos timestamp() const noexcept
Time of request.
Definition: Messages.h:3474
UInt32 Account
Account mnemonic.
Definition: Fields.h:163
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:2726
AllocStatus::Enum allocStatus() const noexcept
Identifies status of allocation.
Definition: Messages.h:25497
ThisType & setRequestTimestamp(UTCTimestampNanos value) noexcept
Matches Negotiate timestamp.
Definition: Messages.h:1121
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:16824
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:20206
ThisType & setSecurityReqId(SecurityReqRespID value) noexcept
Unique ID of a Security Definition Request.
Definition: Messages.h:17684
OrderID orderId() const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:15924
ThisType & setQuoteId(QuoteIDOptional value) noexcept
Unique identifier for quote.
Definition: Messages.h:21722
SecurityReqRespID securityReqId() const noexcept
Unique ID of a Security Definition Request.
Definition: Messages.h:17294
ThisType & setDaysToSettlement(DaysToSettlement value) noexcept
Deadline for completing the forward deal.
Definition: Messages.h:18706
Enum
Indicates additional order instruction.
Definition: Fields.h:1611
static constexpr const Char * className()
Definition: Messages.h:18869
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:6846
RetransmitRequest message is used for client to recover missed messages.
Definition: Messages.h:3357
bool crossType(CrossType::Enum &value) const noexcept
Type of cross being submitted to a market.
Definition: Messages.h:8989
Boolean::Enum mmProtectionReset() const noexcept
Resets Market Protections.
Definition: Messages.h:5877
RetransmitReject14(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:3994
SelfTradePreventionInstruction::Enum selfTradePreventionInstruction() const noexcept
Indicates which order should be cancelled due to Self- Trade Prevention.
Definition: Messages.h:7000
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:405
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:14425
ThisType & setPosTransType(PosTransType::Enum value) noexcept
Identifies the type of position transaction.
Definition: Messages.h:23095
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:16784
UTCTimestampNanos requestTimestamp() const noexcept
Matches Negotiate timestamp.
Definition: Messages.h:1112
ThisType & setMmProtectionReset(Boolean::Enum value) noexcept
Resets Market Protections.
Definition: Messages.h:5123
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:25557
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:3034
ThisType & setBusinessRejectRefId(BusinessRejectRefID value) noexcept
The value of the business-level “ID” field on the message being referenced.
Definition: Messages.h:16728
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:24807
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:6460
BusinessMessageReject206(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:16605
ThisType & setOrderId(OrderIDOptional value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:7226
OrderMassActionReport702(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:26388
MassActionType::Enum massActionType() const noexcept
Specifies the type of action requested.
Definition: Messages.h:26433
Account allocAccount() const noexcept
Sub-account mnemonic.
Definition: Messages.h:24915
bool origClOrdId(ClOrdIDOptional &value) const noexcept
Value of origClOrdID field informed from the related request message.
Definition: Messages.h:14670
IntegralConstant< UInt64, 0ULL > NullQuantityOptional
Null value for an optional QuantityOptional field.
Definition: Fields.h:2414
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:16340
ThisType & setFixedRate(Percentage8Optional value) noexcept
Interest rate of the forward trade.
Definition: Messages.h:21984
ThisType & setTradeDate(Timestamp value) noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:13599
PosMaintStatus::Enum posMaintStatus() const noexcept
Status of Position Maintenance Request.
Definition: Messages.h:23857
ExecutionReportNew200(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:9452
ThisType & setContraBroker(Firm value) noexcept
Broker identifier as assigned by B3 used to indicate the counterparty brokerage firm in a Forward dea...
Definition: Messages.h:21784
StrRef credentials() const noexcept
Credentials to identify/authenticate the client. The format is a JSON with the following data: { "aut...
Definition: Messages.h:1633
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:8511
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:6914
Enum
Defines the type of interest behind a trade i.e. why a trade occurred.
Definition: Fields.h:1867
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:4151
ThisType & setStopPx(PriceOptional value) noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:11332
NegotiateReject3(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:1025
AllocationInstruction601 ThisType
This type alias.
Definition: Messages.h:24520
ThisType & setActionRequestedFromSessionId(SessionIDOptional value) noexcept
Indicates the SessionID that requested the Cancel on behalf.
Definition: Messages.h:12745
bool stopPx(PriceOptional &value) const noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:6207
bool businessRejectRefId(BusinessRejectRefID &value) const noexcept
The value of the business-level “ID” field on the message being referenced.
Definition: Messages.h:16715
ThisType & setSelfTradePreventionInstruction(SelfTradePreventionInstruction::Enum value) noexcept
Indicates which order should be cancelled due to Self- Trade Prevention.
Definition: Messages.h:4546
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:3228
SecurityDefinitionResponse301(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:17594
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:1292
NegotiateResponse2(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:647
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:21005
const OutboundBusinessHeader & businessHeader() const noexcept
Message type = SecurityDefinitionResponse.
Definition: Messages.h:17657
CxlRejResponseTo::Enum cxlRejResponseTo() const noexcept
Identifies current status of order.
Definition: Messages.h:14457
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:5647
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:6164
ThisType & setTradeDate(Timestamp value) noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:9798
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:3240
Enum
Identifies current status of order.
Definition: Fields.h:1667
ThisType & setOrderId(OrderIDOptional value) noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:8021
ThisType & setCrossPrioritization(CrossPrioritization::Enum value) noexcept
Indicates if one side or the other of a cross order should be prioritized.
Definition: Messages.h:9033
#define ONIXS_B3_BOE_DEFAULT
Definition: Compiler.h:208
PositionMaintenanceRequest502(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:22843
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:20618
static constexpr MessageType::Enum messageType() noexcept
Message type = OrderCancelRequest.
Definition: Messages.h:7920
static constexpr MessageType::Enum messageType() noexcept
Message type = NegotiateReject.
Definition: Messages.h:1052
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:3594
OutboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:25288
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:3027
Enum
Reason Order Mass Action Request was rejected.
Definition: Fields.h:756
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:5287
const OutboundBusinessHeader & businessHeader() const noexcept
Message type = PositionMaintenanceReport.
Definition: Messages.h:23707
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:17346
SecurityResponseType::Enum securityResponseType() const noexcept
Type of Security Definition message response.
Definition: Messages.h:17748
ExecutionReportModify201(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:10679
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:3895
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:7960
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for mass cancel on behalf purposes.
Definition: Messages.h:26799
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:24678
bool price(PriceOptional &value) const noexcept
Price per share or contract.
Definition: Messages.h:14841
OrderCancelReplaceRequest104(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:6779
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:26870
OrdStatus::Enum ordStatus() const noexcept
Identifies current status of order.
Definition: Messages.h:15613
bool stopPx(PriceOptional &value) const noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:14872
AllocReportType::Enum allocReportType() const noexcept
Describes the specific type or purpose of an Allocation Report message.
Definition: Messages.h:25401
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:16314
EstablishRejectCode::Enum establishmentRejectCode() const noexcept
Identifies the code of reject establishment.
Definition: Messages.h:2349
ThisType & setPosMaintStatus(PosMaintStatus::Enum value) noexcept
Status of Position Maintenance Request.
Definition: Messages.h:23867
QuoteCancel404 ThisType
This type alias.
Definition: Messages.h:20778
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:19781
SchemaTraits Schema
Used template schema.
Definition: Messages.h:595
ThisType & setSecurityId(SecurityIDOptional value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:26104
ExecutionReportNew200(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:9441
ThisType & setMassActionRejectReason(MassActionRejectReason::Enum value) noexcept
Reason Order Mass Action Request was rejected.
Definition: Messages.h:26588
static constexpr MessageType::Enum messageType() noexcept
Message type = AllocationInstruction.
Definition: Messages.h:24596
SecurityDefinitionRequest300(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:17238
bool price(Price8Optional &value) const noexcept
Price per share or contract.
Definition: Messages.h:19455
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:17427
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:13350
ThisType & setSessionVerId(SessionVerID value) noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:166
ThisType & setTradingSessionId(TradingSessionID::Enum value) noexcept
Identifier for Trading Session.
Definition: Messages.h:13805
TradeID tradeId() const noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:13527
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:4511
RetransmitRequest12(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:3374
ThisType & setStrategyId(StrategyIDOptional value) noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:11553
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:26039
PosTransType::Enum posTransType() const noexcept
Identifies the type of position transaction.
Definition: Messages.h:23815
IntegralConstant< UInt32, 0 > NullSessionIDOptional
Null value for an optional SessionIDOptional field.
Definition: Fields.h:2396
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:22747
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:17046
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:6409
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:2067
bool orderId(OrderIDOptional &value) const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:14640
Negotiate1(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:50
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:19156
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:12175
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:2740
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:18594
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:8323
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for mass cancel on behalf purposes.
Definition: Messages.h:26156
static constexpr MessageType::Enum messageType() noexcept
MessageType.ExecutionReport_Reject.
Definition: Messages.h:14396
bool side(Side::Enum &value) const noexcept
Side of order.
Definition: Messages.h:26030
bool clOrdId(ClOrdIDOptional &value) const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:13164
static constexpr FlowType::Enum clientFlow() noexcept
Type of flow from client to server.
Definition: Messages.h:201
static constexpr MessageType::Enum messageType() noexcept
Message type = SecurityDefinitionResponse.
Definition: Messages.h:17646
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:21047
ExecID execId() const noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:10925
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:6542
ThisType & setLegSymbol(StrRef value) noexcept
Multileg instrument&#39;s individual security’s Symbol.
Definition: Messages.h:17076
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:20548
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:11583
Enum
Identifies the type of request that this cancel reject is in response to.
Definition: Fields.h:1935
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:6529
bool executingTrader(StrRef &value) const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:7366
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:7064
static constexpr MessageType::Enum messageType() noexcept
Message type = OrderMassActionRequest.
Definition: Messages.h:25860
PositionsEntry(void *data, EncodedLength length, SchemaVersion version)
Initializes instance of given version over given memory block.
Definition: Messages.h:23477
bool price(PriceOptional &value) const noexcept
Price per share or contract.
Definition: Messages.h:12489
Negotiate1(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:90
ThisType & setMmProtectionReset(Boolean::Enum value) noexcept
Resets Market Protections.
Definition: Messages.h:10299
SelfTradePreventionInstruction::Enum selfTradePreventionInstruction() const noexcept
Indicates which order should be cancelled due to Self- Trade Prevention.
Definition: Messages.h:4535
QuoteCancel404(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:20802
ThisType & setAllocStatus(AllocStatus::Enum value) noexcept
Identifies status of allocation.
Definition: Messages.h:25506
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:12780
Enum
Identifies the type of request that a Quote Status Report is in response to.
Definition: Fields.h:591
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:10194
AllocTransType::Enum allocTransType() const noexcept
Identifies allocation transaction type.
Definition: Messages.h:25378
AllocationInstruction601(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:24544
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:6576
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:2992
Enum
Identifies the class of the SecurityID.
Definition: Fields.h:1988
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:3462
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:8881
UTCTimestampNanos requestTimestamp() const noexcept
Matches Negotiate timestamp.
Definition: Messages.h:3785
ThisType & setQuoteIdToNull() noexcept
Definition: Messages.h:20974
bool fixedRate(Percentage8Optional &value) const noexcept
Interest rate of the forward trade.
Definition: Messages.h:19572
ThisType & setMassActionType(MassActionType::Enum value) noexcept
Specifies the type of action requested.
Definition: Messages.h:26443
ThisType & setMassActionType(MassActionType::Enum value) noexcept
Specifies the type of action requested.
Definition: Messages.h:25899
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:5835
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:20520
ThisType & setTradeDate(Timestamp value) noexcept
Indicates date of trading day (expressed in local time at place of trade).
Definition: Messages.h:11120
ThisType & setKeepAliveInterval(DeltaInMillis value) noexcept
Longest time in milliseconds the initiator should remain silent before sending Sequence message...
Definition: Messages.h:1549
bool executingTrader(StrRef &value) const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:8167
SeqNum refSeqNum() const noexcept
Message sequence number of rejected message.
Definition: Messages.h:16692
Enum
Specifies the scope of the action. All Day and MOC orders will be cancelled. GTC, GTD and MOA orders ...
Definition: Fields.h:681
OrdStatus::Enum ordStatus() const noexcept
Identifies current status of order.
Definition: Messages.h:10766
char Char
Character type alias.
Definition: String.h:30
ThisType & setOrdStatus(OrdStatus::Enum value) noexcept
Identifies current status of order.
Definition: Messages.h:9526
ThisType & setCrossPrioritizationToNull() noexcept
Definition: Messages.h:9043
Header used for outbound business messages.
Definition: Composites.h:1410
const void * tail() const noexcept
Definition: Messages.h:18890
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:18472
OrderID orderId() const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:13568
ThisType & setClearingBusinessDate(Timestamp value) noexcept
The &#39;Clearing Business Date&#39; referred to by this request.
Definition: Messages.h:23117
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:12468
Terminate7(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:2613
static constexpr MessageType::Enum messageType() noexcept
Message type = RetransmitReject.
Definition: Messages.h:4061
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:8155
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:8298
SbeGroupEntry< GroupSizeEncoding::BlockLength > Base
Base class type.
Definition: Messages.h:17028
bool quoteId(QuoteIDOptional &value) const noexcept
Unique identifier for quote.
Definition: Messages.h:18381
ThisType & setBusinessRejectReason(RejReason value) noexcept
Code to identify the reason of the rejection.
Definition: Messages.h:16758
SbeGroup< SidesEntry, GroupSizeEncoding, MessageSize > Sides
Repeating group containing SidesEntry entries.
Definition: Messages.h:8672
AllocationReport602(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:25201
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:5207
EstablishAck5 ThisType
This type alias.
Definition: Messages.h:1826
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:4439
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:2425
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:24309
ThisType & setSelfTradePreventionInstruction(SelfTradePreventionInstruction::Enum value) noexcept
Indicates which order should be cancelled due to Self- Trade Prevention.
Definition: Messages.h:5242
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:13773
ThisType & setMarketSegmentReceivedTime(UTCTimestampNanosOptional value) noexcept
Time of receipt of related inbound message in the market segment path.
Definition: Messages.h:12202
bool receivedTime(UTCTimestampNanosOptional &value) const noexcept
Time of receipt of related inbound message in the gateway.
Definition: Messages.h:15027
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:2714
Quantity lastQty() const noexcept
Quantity of shares bought/sold on the last fill.
Definition: Messages.h:15758
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:4449
ThisType & setMultiLegReportingTypeToNull() noexcept
Definition: Messages.h:9857
Price price() const noexcept
Price per share or contract.
Definition: Messages.h:8934
ThisType & setFromSeqNo(SeqNum value) noexcept
The first applied sequence number.
Definition: Messages.h:2946
Positions positions(Positions::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:24191
AllocationReport602(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:25241
Enum
Specifies the action taken by matching engine when it receives the Order Mass Action Request...
Definition: Fields.h:731
SeqNum nextSeqNo() const noexcept
The next application sequence number to be produced by the gateway.
Definition: Messages.h:2005
ThisType & setCurrentSessionVerIdToNull() noexcept
Definition: Messages.h:1221
Enum
Identifier for Trading Session.
Definition: Fields.h:2041
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:9131
Identifies the version of what the field relates to.
Definition: Composites.h:2086
OrdType::Enum ordType() const noexcept
Order type.
Definition: Messages.h:11190
QuoteStatusReport402(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:19030
ThisType & setRoutingInstruction(RoutingInstruction::Enum value) noexcept
Indicates additional order instruction.
Definition: Messages.h:6134
SchemaTraits Schema
Used template schema.
Definition: Messages.h:11860
OrdType::Enum ordType() const noexcept
Order type.
Definition: Messages.h:7084
bool crossId(CrossIDOptional &value) const noexcept
ID of electronically submitted cross order by the institution (if in response to a cross order)...
Definition: Messages.h:13710
PositionMaintenanceCancelRequest501 ThisType
This type alias.
Definition: Messages.h:22414
OrderMassActionReport702 ThisType
This type alias.
Definition: Messages.h:26328
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:10463
ThisType & setStopPx(PriceOptional value) noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:10010
Enum
Indicates if one side or the other of a cross order should be prioritized.
Definition: Fields.h:2169
NewOrderSingle102(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:5777
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:22169
SchemaTraits Schema
Used template schema.
Definition: Messages.h:26325
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:6556
bool origPosReqRefId(PosReqIDOptional &value) const noexcept
Reference to the PosReqID (710) of a previous maintenance request that is being cancelled.
Definition: Messages.h:23913
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:8485
PosMaintAction::Enum posMaintAction() const noexcept
Maintenance Action to be performed.
Definition: Messages.h:23835
BidirectionalBusinessHeader & businessHeader() noexcept
Common header to all bidirectional business messages.
Definition: Messages.h:19118
SessionVerID sessionVerId() const noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:2665
bool accountType(AccountType::Enum &value) const noexcept
Type of account associated with an order.
Definition: Messages.h:23943
bool orderCategory(OrderCategory::Enum &value) const noexcept
Reason why a trade occurred.
Definition: Messages.h:13459
ThisType & setOrigPosReqRefId(PosReqIDOptional value) noexcept
Reference to the PosReqID (710) of a previous maintenance request that is being cancelled.
Definition: Messages.h:23923
EstablishAck5(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:1850
Enum
Identifies the type of quote cancel.
Definition: Fields.h:622
bool maxFloor(QuantityOptional &value) const noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:11382
MessageSize EncodedLength
Length of the message binary data.
Definition: SbeMessage.h:1136
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:19537
Optional UTC timestamp with nanosecond precision.
Definition: Composites.h:586
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:21404
ThisType & setMassActionScope(MassActionScope::Enum value) noexcept
Specifies the scope of the action.
Definition: Messages.h:26467
ThisType & setPosMaintRptId(PosMaintRptID value) noexcept
Unique identifier for this position report.
Definition: Messages.h:23804
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:8893
ThisType & setWorkingIndicator(Boolean::Enum value) noexcept
Indicates if an order has been triggered and is available for trading.
Definition: Messages.h:9822
SessionVerID sessionVerId() const noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:1490
SimpleNewOrder100(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:4325
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:21815
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:24320
ThisType & setTimeInForce(TimeInForce::Enum value) noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:11219
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:7603
ThisType & setMmProtectionReset(Boolean::Enum value) noexcept
Resets Market Protections.
Definition: Messages.h:4427
OutboundBusinessHeader & businessHeader() noexcept
Common header to all outbound business messages.
Definition: Messages.h:16663
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:5577
ThisType & setOrdRejReason(RejReason value) noexcept
Code to identify reason for order rejection.
Definition: Messages.h:14587
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:14481
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:19299
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:17401
ThisType & setSessionVerId(SessionVerID value) noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:1503
ThisType & setStopPx(PriceOptional value) noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:6217
NegotiateResponse2 ThisType
This type alias.
Definition: Messages.h:598
const OutboundBusinessHeader & businessHeader() const noexcept
MessageType.ExecutionReport_Trade.
Definition: Messages.h:13105
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:5844
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:25008
bool origClOrdId(ClOrdIDOptional &value) const noexcept
ClOrdID which should be replaced.
Definition: Messages.h:7246
ThisType & setMinQty(QuantityOptional value) noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:14911
ThisType & setSecondaryExecId(ExecIDOptional value) noexcept
Unique identifier present in all messages associated with a spread transaction.
Definition: Messages.h:13658
Enum
Specifies how long the order remains in effect.
Definition: Fields.h:1478
const BidirectionalBusinessHeader & businessHeader() const noexcept
Message type = QuoteRequestReject.
Definition: Messages.h:21604
StrRef enteringTrader() const noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:6976
UInt64 AllocID
Unique identifier for this allocation instruction message.
Definition: Fields.h:85
AllocationReport602 ThisType
This type alias.
Definition: Messages.h:25192
ThisType & setMassActionScope(MassActionScope::Enum value) noexcept
Specifies the scope of the action.
Definition: Messages.h:25923
Retransmission message is sent when a RetransmitRequest message from the client is accepted by B3...
Definition: Messages.h:3669
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:15203
bool price(PriceOptional &value) const noexcept
Price per share or contract.
Definition: Messages.h:4717
IntegralConstant< UInt64, 0ULL > NullPosReqIDOptional
Null value for an optional PosReqIDOptional field.
Definition: Fields.h:2468
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:4599
ThisType & setOrderQty(Quantity value) noexcept
Quantity ordered.
Definition: Messages.h:5401
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:15089
Quote403(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:20057
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:20686
SchemaTraits Schema
Used template schema.
Definition: Messages.h:25189
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:26882
OrderID secondaryOrderId() const noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:15666
PositionMaintenanceRequest502(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:22858
StrRef deskId() const noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:21106
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:17947
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:8612
const void * tail() const noexcept
Definition: Messages.h:3626
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:1073
ThisType & setEnteringFirm(Firm value) noexcept
Identifies the broker firm that will enter orders.
Definition: Messages.h:789
bool execRestatementReason(ExecRestatementReasonValidForSingleCancel::Enum &value) const noexcept
Used to communicate a reason for a solicited cancel.
Definition: Messages.h:8091
ThisType & setAccountType(AccountType::Enum value) noexcept
Type of account associated with an order.
Definition: Messages.h:23952
QuoteCancel404(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:20816
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:26499
ThisType & setTradeId(TradeID value) noexcept
The unique ID assigned to the trade entity once it is received or matched by the exchange or central ...
Definition: Messages.h:24842
NegotiateReject3(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:1014
AllocationReport message is as response of AllocationInstruction message.
Definition: Messages.h:25184
UTCTimestampNanos timestamp() const noexcept
Time of request.
Definition: Messages.h:1515
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:15180
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:19515
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:9506
UInt64 Quantity
Quantity in order/trade.
Definition: Fields.h:139
SchemaTraits Schema
Used template schema.
Definition: Messages.h:973
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:21652
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:3266
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:22980
Enum
Used to communicate event type which triggers mass cancelation.
Definition: Fields.h:1735
Quantity leavesQty() const noexcept
Amount of shares open for further execution, or unexecuted.
Definition: Messages.h:10874
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:20917
SimpleNewOrder100(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:4285
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:8177
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:8133
ThisType & setStrategyId(StrategyIDOptional value) noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:6440
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:11629
ThisType & setRequestTimestamp(UTCTimestampNanos value) noexcept
Matches Negotiate timestamp.
Definition: Messages.h:4102
ThisType & setAllocRejCode(RejReasonOptional value) noexcept
Identifies reason for rejection.
Definition: Messages.h:25457
static constexpr MessageType::Enum messageType() noexcept
Message type = PositionMaintenanceCancelRequest.
Definition: Messages.h:22490
IntegralConstant< UInt16, 0 > NullLocalMktDateOptional
Null value for an optional LocalMktDateOptional field.
Definition: Fields.h:2420
ThisType & setDaysToSettlement(DaysToSettlementOptional value) noexcept
Deadline for completing the forward deal.
Definition: Messages.h:19672
SecurityReqRespID securityResponseId() const noexcept
Unique ID of a Security Definition message.
Definition: Messages.h:17830
IntegralConstant< UInt8, 255 > NullUInt8
Null value for an optional UInt8 field.
Definition: Fields.h:38
ThisType & setWorkingIndicator(Boolean::Enum value) noexcept
Indicates if an order has been triggered and is available for trading.
Definition: Messages.h:11144
ThisType & setMmProtectionReset(Boolean::Enum value) noexcept
Resets Market Protections.
Definition: Messages.h:5890
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:15300
ThisType & setDaysToSettlement(DaysToSettlement value) noexcept
Deadline for completing the forward deal.
Definition: Messages.h:20499
SimpleNewOrder100(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:4314
static constexpr const Char * className()
Definition: Messages.h:3913
QuoteRequest401(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:18263
Establish4(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:1438
AllocationReport602(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:25252
ThisType & setMinQty(QuantityOptional value) noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:11361
static constexpr MessageType::Enum messageType() noexcept
Message type = SimpleNewOrder.
Definition: Messages.h:4352
ThisType & setSessionVerId(SessionVerID value) noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:1951
ThisType & setAllocReportId(AllocReportID value) noexcept
Unique identifier for this message.
Definition: Messages.h:25367
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:18824
StrRef memo() const noexcept
Type of account associated with an order.
Definition: Messages.h:5543
SettlType::Enum settlType() const noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:20298
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:7683
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:21413
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:26229
OrderID orderId() const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:11023
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:5512
ThisType & setCrossType(CrossType::Enum value) noexcept
Type of cross being submitted to a market.
Definition: Messages.h:13903
UInt8 TotNoRelatedSym
Number of leg fill notice messages sent with spread summary.
Definition: Fields.h:375
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:20510
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:3566
ExecID execId() const noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:12145
QuoteCancel404(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:20787
Null values definition for optional Version field.
Definition: Composites.h:2225
ThisType & setWorkingIndicator(Boolean::Enum value) noexcept
Indicates if an order has been triggered and is available for trading.
Definition: Messages.h:12309
ThisType & setLongQty(Quantity value) noexcept
Long quantity.
Definition: Messages.h:23202
ThisType & setExpireDate(Timestamp value) noexcept
Date of order expiration (last day the order can trade), always expressed in terms of the local marke...
Definition: Messages.h:12448
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:17977
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:4489
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:21114
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:20125
SchemaTraits Schema
Used template schema.
Definition: Messages.h:17006
const BidirectionalBusinessHeader & businessHeader() const noexcept
Message type = QuoteRequest.
Definition: Messages.h:18301
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:14434
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:23614
Null values definition for optional ImpliedEventID field.
Definition: Composites.h:2035
static constexpr const Char * className()
Definition: Messages.h:3293
UInt64 ClOrdID
Unique identifier of the order as assigned by the market participant.
Definition: Fields.h:91
ThisType & setRequestTimestamp(UTCTimestampNanos value) noexcept
Matches Negotiate timestamp.
Definition: Messages.h:1971
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:21173
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:12899
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:25644
ThisType & setOnbehalfFirm(FirmOptional value) noexcept
Identifies the broker firm who executes their orders on behalf.
Definition: Messages.h:243
Header used for business messages that can go inbound or outbound.
Definition: Composites.h:1607
ThisType & setLeavesQty(Quantity value) noexcept
Amount of shares open for further execution, or unexecuted.
Definition: Messages.h:10884
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:1315
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:8581
static constexpr const Char * className()
Definition: Messages.h:4204
Retransmission13(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:3737
static constexpr const Char * className()
Definition: Messages.h:26918
ThisType & setCustodianInfo(CustodianInfo value) noexcept
Identifies the custodian.
Definition: Messages.h:7476
Legs legs(Legs::Size length, NoFieldsInit)
Setup repeating group with the given number of entries.
Definition: Messages.h:17386
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:5086
SelfTradePreventionInstruction::Enum selfTradePreventionInstruction() const noexcept
Indicates which order should be cancelled due to Self- Trade Prevention.
Definition: Messages.h:5998
ExecutionReportForward205(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:15497
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:10895
PositionMaintenanceCancelRequest is a solicited cancel of PositionMaintenance message sent by client...
Definition: Messages.h:22406
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:3860
UInt32 TradeIDOptional
Optional unique identification assigned to the trade entity once it is received or matched by the exc...
Definition: Fields.h:345
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:13218
AllocationReport602(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:25216
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:24666
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:20884
Enum
Identifies the status of the quote acknowledgement.
Definition: Fields.h:551
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:9223
PositionMaintenanceRequest message allows the position owner (holder) to submit requests which will a...
Definition: Messages.h:22826
QuoteStatusReport402(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:19059
Sequence message specifies the sequence number of the next business message both: Recoverable (B3 to ...
Definition: Messages.h:3109
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:10380
TradeID tradeId() const noexcept
Contains the unique identifier for this trade, per instrument + trading date, as assigned by the exch...
Definition: Messages.h:15883
static constexpr MessageType::Enum messageType() noexcept
Message type = Sequence.
Definition: Messages.h:3193
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:913
Execution Report – Forward message is sent with order fills were traded and processed on Matching En...
Definition: Messages.h:15480
ThisType & setPrice(PriceOptional value) noexcept
Price per share or contract.
Definition: Messages.h:11301
ThisType & setSettlType(SettlType::Enum value) noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:21848
ThisType & setQuantity(Quantity value) noexcept
Overall/total quantity (e.g. number of shares).
Definition: Messages.h:25486
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:26950
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:9644
UInt64 PosReqID
Unique identifier for the position maintenance request.
Definition: Fields.h:257
static constexpr UInt64 getMaxMessageSize(UInt8 maxGroupItems=255) noexcept
Maximal message size.
Definition: Messages.h:17441
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:24029
bool semanticVersion(Version &value) const noexcept
Identifies the semantic version of the schema used in this session.
Definition: Messages.h:801
OrderMassActionRequest701 ThisType
This type alias.
Definition: Messages.h:25784
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Definition: Messages.h:17155
UTC timestamp with nanosecond precision.
Definition: Composites.h:498
bool marketSegmentReceivedTime(UTCTimestampNanosOptional &value) const noexcept
Time of receipt of related inbound message in the market segment path.
Definition: Messages.h:12189
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:10946
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:9213
ExecutionReportForward205 ThisType
This type alias.
Definition: Messages.h:15488
bool massActionReportId(MassActionReportIDOptional &value) const noexcept
Unique ID of Order Mass Action Report as assigned by the matching engine.
Definition: Messages.h:12355
static constexpr const Char * className()
Definition: Messages.h:10514
RetransmitReject14(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:4045
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:5565
ThisType & setMassActionReportId(MassActionReportID value) noexcept
Unique ID of Order Mass Action Report as assigned by the matching engine.
Definition: Messages.h:26521
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:8765
bool stopPx(PriceOptional &value) const noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:11322
PositionMaintenanceReport503(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:23680
ThisType & setCrossedIndicator(CrossedIndicator::Enum value) noexcept
Indicates cross order purpose.
Definition: Messages.h:13752
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:15602
bool maxFloor(QuantityOptional &value) const noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:12580
bool orderQty(QuantityOptional &value) const noexcept
Quantity ordered.
Definition: Messages.h:21899
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:7588
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:23254
QuoteReqID quoteReqId() const noexcept
Unique identifier for quote request.
Definition: Messages.h:20166
TimeInForce::Enum timeInForce() const noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:12408
bool fixedRate(Percentage8Optional &value) const noexcept
Interest rate of the forward trade.
Definition: Messages.h:21973
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:8345
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:4558
const void * tail() const noexcept
Definition: Messages.h:439
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:13123
ThisType & setLastQty(Quantity value) noexcept
Quantity of shares bought/sold on the last fill.
Definition: Messages.h:15767
ThisType & setQuoteStatusResponseTo(QuoteStatusResponseTo::Enum value) noexcept
Identifies the type of request that a Quote Status Report is in response to.
Definition: Messages.h:19344
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:15820
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:8591
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:3578
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:19757
bool thresholdAmount(PriceOffsetOptional &value) const noexcept
Used to indicate the minimum acceptable offset between the Strike Price and the Market Price...
Definition: Messages.h:23996
The NewOrderCross message submits a Cross on Order Entry gateway, a two-sided order submitted by a si...
Definition: Messages.h:8433
NotApplied8(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:2889
OrderCancelRequest105(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:7868
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:21035
ThisType & setNextSeqNo(SeqNum value) noexcept
The sequence number of the first retransmitted message.
Definition: Messages.h:3814
#define ONIXS_B3_BOE_LTWT_EXPORTED
Definition: ABI.h:92
EstablishAck5(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:1875
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:12819
UInt64 QuoteID
Unique identifier for quote.
Definition: Fields.h:351
Quantity leavesQty() const noexcept
Amount of shares open for further execution, or unexecuted.
Definition: Messages.h:13371
bool stopPx(PriceOptional &value) const noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:7276
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:24226
OrderID secondaryOrderId() const noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:13196
OutboundBusinessHeader & businessHeader() noexcept
Common header to all outbound business messages.
Definition: Messages.h:14416
ThisType & setPriceToNull() noexcept
Definition: Messages.h:20246
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:23239
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:5669
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:16294
SeqNum nextSeqNo() const noexcept
The next application sequence number to be produced by the client.
Definition: Messages.h:1561
NegotiateReject3(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:1036
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:21079
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:8079
ThisType & setInvestorId(InvestorID value) noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:15099
EstablishAck5(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:1886
OrderCancelReplaceRequest104(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:6790
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:2055
NegotiateResponse2(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:658
ExecID execId() const noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:13329
IntegralConstant< UInt32, 0 > NullAccountOptional
Null value for an optional AccountOptional field.
Definition: Fields.h:2426
SchemaTraits Schema
Used template schema.
Definition: Messages.h:3362
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:6623
bool strategyId(StrategyIDOptional &value) const noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:15120
ThisType & setOnbehalfFirmToNull() noexcept
Definition: Messages.h:252
Terminate7(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:2591
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:17413
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:21193
SchemaTraits Schema
Used template schema.
Definition: Messages.h:1375
ThisType & setRoutingInstruction(RoutingInstruction::Enum value) noexcept
Indicates additional order instruction.
Definition: Messages.h:4675
ThisType & setOrdStatus(OrdStatus::Enum value) noexcept
Identifies current status of order.
Definition: Messages.h:11997
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:26489
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:21381
ThisType & setTotNoRelatedSym(TotNoRelatedSym value) noexcept
Number of leg fill notice messages sent with spread summary.
Definition: Messages.h:13621
static constexpr MessageType::Enum messageType() noexcept
Message type = SimpleModifyOrder.
Definition: Messages.h:5048
static constexpr const Char * className()
Definition: Messages.h:16881
NegotiateReject3(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:1000
OrderCancelRequest105(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:7853
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:14535
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:19828
const void * tail() const noexcept
Definition: Messages.h:2800
IntegralConstant< UInt32, 0 > NullRejReasonOptional
Null value for an optional RejReasonOptional field.
Definition: Fields.h:2456
bool marketSegmentReceivedTime(UTCTimestampNanosOptional &value) const noexcept
Time of receipt of related inbound message in the market segment path.
Definition: Messages.h:9718
ExecutionReportNew200(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:9416
ThisType & setExecuteUnderlyingTradeToNull() noexcept
Definition: Messages.h:20460
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:888
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:8502
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:23300
Attributes of SBE message schema.
Definition: SchemaTraits.h:37
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:22157
StrRef executingTrader() const noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:19549
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:23213
ExecutionReportModify201 ThisType
This type alias.
Definition: Messages.h:10641
static constexpr StrRef legSecurityExchange() noexcept
Exchange code the leg security belongs to.
Definition: Messages.h:17090
ThisType & setExecType(ExecType::Enum value) noexcept
Describes the action that triggered this specific Execution Report - see the OrdStatus (39) tag for t...
Definition: Messages.h:13447
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:26855
Quote403(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:20028
static constexpr const Char * className()
Definition: Messages.h:12890
ThisType & setExecRestatementReason(ExecRestatementReasonValidForSingleCancel::Enum value) noexcept
Used to communicate a reason for a solicited cancel.
Definition: Messages.h:8102
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:7044
bool multiLegReportingType(MultiLegReportingType::Enum &value) const noexcept
Used to indicate what an Execution Report represents.
Definition: Messages.h:13493
Enum
Indicates who in the contract has control over evoking settlement.
Definition: Fields.h:921
UInt64 QuantityOptional
Optional quantity in order/trade.
Definition: Fields.h:145
Retransmission13 ThisType
This type alias.
Definition: Messages.h:3677
NegotiationRejectCode::Enum negotiationRejectCode() const noexcept
Identifies the code of reject negotiation.
Definition: Messages.h:1175
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:12054
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:8070
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:7640
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:25682
Enum
Criteria used to initiate cancel on disconnect mechanism by the gateway.
Definition: Fields.h:1422
Boolean::Enum contraryInstructionIndicator() const noexcept
Used to indicate when a contrary instruction for exercise or abandonment is being submitted: The exer...
Definition: Messages.h:23134
ThisType & setPrice(PriceOptional value) noexcept
Price per share or contract.
Definition: Messages.h:9979
RetransmitReject14(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:4023
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:25350
Quantity quantity() const noexcept
Overall/total quantity (e.g. number of shares).
Definition: Messages.h:24754
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:25338
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:23763
SeqNum nextSeqNo() const noexcept
Message type = Sequence.
Definition: Messages.h:3204
RetransmitRequest12 ThisType
This type alias.
Definition: Messages.h:3365
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:4165
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:8828
UInt32 SeqNum
Sequence number of a given SessionID/SessionVerID.
Definition: Fields.h:127
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:3054
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:7166
SimpleModifyOrder101(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:4996
SchemaTraits Schema
Used template schema.
Definition: Messages.h:4969
DaysToSettlement daysToSettlement() const noexcept
Specifies whether a quote is public, i.e.
Definition: Messages.h:18695
OutboundBusinessHeader & businessHeader() noexcept
Common header to all outbound business messages.
Definition: Messages.h:17666
ThisType & setAggressorIndicator(Boolean::Enum value) noexcept
Identify whether the order initiator is an aggressor or not in the trade.
Definition: Messages.h:13423
static constexpr MessageType::Enum messageType() noexcept
Message type = AllocationReport.
Definition: Messages.h:25268
ThisType & setReceivedTime(UTCTimestampNanosOptional value) noexcept
Time of receipt of related inbound message in the gateway.
Definition: Messages.h:11424
bool settlType(SettlType::Enum &value) const noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:19424
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:26193
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:21121
bool orderId(OrderIDOptional &value) const noexcept
Unique identifier for order as assigned by the exchange.
Definition: Messages.h:5443
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:22693
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:25051
ThisType & setCrossedIndicator(CrossedIndicator::Enum value) noexcept
Indicates cross order purpose.
Definition: Messages.h:8967
ThisType & setExecId(ExecID value) noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:14629
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:5135
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:26208
ThisType & setCredentials(StrRef value)
Credentials to identify/authenticate the client. The format is a JSON with the following data: { "aut...
Definition: Messages.h:300
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:1686
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:16329
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:24058
bool receivedTime(UTCTimestampNanosOptional &value) const noexcept
Time of receipt of related inbound message in the gateway.
Definition: Messages.h:10122
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:8478
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:10419
ThisType & setMemo(StrRef value)
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:14079
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:22992
Retransmission13(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:3701
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:24289
const OutboundBusinessHeader & businessHeader() const noexcept
MessageType.ExecutionReport_Reject.
Definition: Messages.h:14407
Boolean::Enum mmProtectionReset() const noexcept
Resets Market Protections.
Definition: Messages.h:6879
bool strategyId(StrategyIDOptional &value) const noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:7528
bool longQty(QuantityOptional &value) const noexcept
Long Quantity.
Definition: Messages.h:23527
const void * tail() const noexcept
Definition: Messages.h:9261
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:4696
StrRef clientAppName() const noexcept
Application name as informed during certification process.
Definition: Messages.h:281
QuoteRequestReject405 ThisType
This type alias.
Definition: Messages.h:21344
QuoteRequestReject405(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:21577
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:4608
const OutboundBusinessHeader & businessHeader() const noexcept
MessageType.ExecutionReport_Forward.
Definition: Messages.h:15575
PosReqID posReqId() const noexcept
Unique identifier for the position maintenance request.
Definition: Messages.h:22939
UTCTimestampNanos transactTime() const noexcept
Time of execution/order creation.
Definition: Messages.h:9695
ThisType & setContraBroker(Firm value) noexcept
Broker identifier as assigned by B3 used to indicate the counterparty brokerage firm in a Forward dea...
Definition: Messages.h:19279
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:18078
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:6585
bool maxFloor(QuantityOptional &value) const noexcept
Maximum number of shares or contracts within an order to be shown on the match engine at any given ti...
Definition: Messages.h:10060
Null values definition for optional Percentage8Optional field.
Definition: Composites.h:428
Enum
Indicates which order should be cancelled due to self-trade prevention.
Definition: Fields.h:949
OrderID secondaryOrderId() const noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:12032
static constexpr FlowType::Enum clientFlow() noexcept
Type of flow from client to server.
Definition: Messages.h:1134
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:15290
ExecutionReportTrade203(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:13042
bool securityStrategyType(StrRef &value) const noexcept
Indicates the type of Strategy created.
Definition: Messages.h:17771
UTCTimestampNanos requestTimestamp() const noexcept
Matches Negotiate timestamp.
Definition: Messages.h:1962
bool minQty(QuantityOptional &value) const noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:6237
PositionMaintenanceReport message is sent owner of a position (holder) in response to a PositionMaint...
Definition: Messages.h:23443
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:4880
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:18772
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:10853
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:5502
ThisType & setOrdTagId(OrdTagID value) noexcept
Identifies the order tag identification.
Definition: Messages.h:4390
bool ordTagId(OrdTagID &value) const noexcept
Identifies the order tag identification.
Definition: Messages.h:10154
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:20328
bool securityId(SecurityIDOptional &value) const noexcept
Security identification as defined by exchange.
Definition: Messages.h:17696
Boolean::Enum workingIndicator() const noexcept
Indicates if an order has been triggered and is available for trading.
Definition: Messages.h:12298
ExecutionReportCancel202(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:11887
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:22705
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:2515
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:3282
QuoteRequest401(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:18238
ThisType & setStrategyId(StrategyIDOptional value) noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:15130
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:6934
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:18844
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:26179
ThisType & setClOrdId(ClOrdID value) noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:9548
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:8254
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:8004
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:17882
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:348
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:17850
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:8214
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:22740
ThisType & setContraBroker(Firm value) noexcept
Broker identifier as assigned by B3 used to indicate the counterparty brokerage firm in a Forward dea...
Definition: Messages.h:18452
ThisType & setCount(MessageCounter value) noexcept
How many messages haven´t been applied?.
Definition: Messages.h:2966
ThisType & setLastIncomingSeqNo(SeqNum value) noexcept
Indicates the application sequence number of the last application message received by the server from...
Definition: Messages.h:2041
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:10480
AllocationReport602(void *data, EncodedLength length, NoInit)
Creates an instance over the given memory block.
Definition: Messages.h:25230
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:21433
static constexpr const Char * className()
Definition: Messages.h:22234
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:22719
AllocTransType::Enum allocTransType() const noexcept
Identifies allocation transaction type.
Definition: Messages.h:24686
ExecutionReportCancel202(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:11872
BusinessMessageReject206(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:16627
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:10955
NewOrderSingle102(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:5799
Quantity leavesQty() const noexcept
Amount of shares open for further execution, or unexecuted.
Definition: Messages.h:15841
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:24795
bool onbehalfFirm(FirmOptional &value) const noexcept
Identifies the broker firm who executes their orders on behalf.
Definition: Messages.h:233
#define ONIXS_B3_BOE_CONST_OR_CONSTEXPR
Definition: Compiler.h:184
OrderID secondaryOrderId() const noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:9561
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:22770
NegotiateReject3(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:985
TimeInForce::Enum timeInForce() const noexcept
Specifies how long the order remains in effect.
Definition: Messages.h:6102
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:14068
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:23170
ExecutionReportTrade203 ThisType
This type alias.
Definition: Messages.h:13018
OrderMassActionRequest is sent by the client system to cancel working orders that belongs to a define...
Definition: Messages.h:25776
SecurityReqRespID securityReqId() const noexcept
Unique ID of a Security Definition Request.
Definition: Messages.h:17675
ThisType & setSecondaryOrderId(OrderID value) noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:13207
ThisType & setClientAppVersion(StrRef value)
Application version as informed during certification process.
Definition: Messages.h:333
ExecutionReportCancel202 ThisType
This type alias.
Definition: Messages.h:11863
SchemaTraits Schema
Used template schema.
Definition: Messages.h:21341
AllocationInstruction message submits a request to allocate (fully or partially) a non-allocated trad...
Definition: Messages.h:24512
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:18810
OutboundBusinessHeader & businessHeader() noexcept
Common header to all outbound business messages.
Definition: Messages.h:11959
Boolean::Enum contraryInstructionIndicator() const noexcept
Used to indicate when a contrary instruction for exercise or abandonment is being submitted :The exer...
Definition: Messages.h:24137
ExecutionReportForward205(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:15512
SecurityDefinitionResponse301(void *data, EncodedLength length, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block.
Definition: Messages.h:17579
AllocID allocId() const noexcept
Unique identifier for this allocation instruction message.
Definition: Messages.h:25297
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:5217
UInt64 OrderID
Exchange-generated order identifier.
Definition: Fields.h:213
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:4826
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:5263
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:26220
ThisType & setTimestamp(UTCTimestampNanos value) noexcept
Time of request.
Definition: Messages.h:1525
static constexpr BlockLength minimalBlockLength(SchemaVersion version) noexcept
Minimal size of message body in bytes.
Definition: Messages.h:3540
bool enteringFirm(FirmOptional &value) const noexcept
Type of flow from client to server.
Definition: Messages.h:1145
ThisType & setLastIncomingSeqNoToNull() noexcept
Definition: Messages.h:2397
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:7971
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:22646
bool asset(StrRef &value) const noexcept
Asset associated with the security, such as DOL, BGI, OZ1, WDL, CNI, etc.
Definition: Messages.h:26703
ThisType & setCrossId(CrossID value) noexcept
ID of electronically submitted cross order by the institution (if in response to a cross order)...
Definition: Messages.h:8785
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:24970
SchemaTraits Schema
Used template schema.
Definition: Messages.h:4273
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:15721
static constexpr const Char * className()
Entity class name.
Definition: Messages.h:17183
DeltaInMillis codTimeoutWindow() const noexcept
Gateway will not trigger CoD if the customer reconnects within the timeout window (milliseconds) whic...
Definition: Messages.h:1610
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:2081
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:3639
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:10184
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:5952
ThisType & setText(StrRef value)
Free ASCII format text string.
Definition: Messages.h:26826
ThisType & setSettlType(SettlType::Enum value) noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:18516
bool orderQty(QuantityOptional &value) const noexcept
Quantity ordered.
Definition: Messages.h:14810
ThisType & setTradingSubAccount(AccountOptional value)
Account used for associating risk limits (when defined).
Definition: Messages.h:6470
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:18878
ThisType & setEnteringTrader(StrRef value) noexcept
Identifies the trader who is inserting an order.
Definition: Messages.h:22678
IntegralConstant< UInt8, 0 > NullTotNoRelatedSym
Null value for an optional TotNoRelatedSym field.
Definition: Fields.h:2528
static constexpr const Char * className()
Definition: Messages.h:16439
ExecutionReportTrade203(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:13067
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:17285
ThisType & setSenderLocation(StrRef value) noexcept
Identifies the original location for routing orders.
Definition: Messages.h:20358
Null values definition for optional PriceOptional field.
Definition: Composites.h:202
ThisType & setText(StrRef value)
Free ASCII format text string.
Definition: Messages.h:19768
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:6925
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:22195
Firm contraBroker() const noexcept
Broker identifier as assigned by B3 used to indicate the counterparty brokerage firm in a Forward dea...
Definition: Messages.h:21774
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:4469
SelfTradePreventionInstruction::Enum selfTradePreventionInstruction() const noexcept
Indicates which order should be cancelled due to Self- Trade Prevention.
Definition: Messages.h:5231
QuoteReqID quoteReqId() const noexcept
Unique identifier for quote request.
Definition: Messages.h:21693
UInt32 TradeID
The unique identification assigned to the trade entity once it is received or matched by the exchange...
Definition: Fields.h:339
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:26264
Price lastPx() const noexcept
Price of last fill.
Definition: Messages.h:15778
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:18638
Enum
Type of message flow from client to server or from server to client.
Definition: Fields.h:1147
SchemaTraits Schema
Used template schema.
Definition: Messages.h:2848
ThisType & setCrossId(CrossIDOptional value) noexcept
ID of electronically submitted cross order by the institution (if in response to a cross order)...
Definition: Messages.h:13720
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:2452
Firm enteringFirm() const noexcept
Type of flow from client to server.
Definition: Messages.h:780
Establish4 ThisType
This type alias.
Definition: Messages.h:1378
ThisType & setQuoteReqId(QuoteReqID value) noexcept
Unique identifier for quote request.
Definition: Messages.h:20175
bool asset(StrRef &value) const noexcept
Asset associated with the security, such as DOL, BGI, OZ1, WDL, CNI, etc.
Definition: Messages.h:26060
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:9178
Boolean::Enum mmProtectionReset() const noexcept
Resets Market Protections.
Definition: Messages.h:4414
StrRef deskId() const noexcept
Identifies the trading desk.
Definition: Messages.h:24203
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:7674
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:17954
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:16913
NotApplied message is sent when B3 detects messages that already been sent (concept of idempotence) o...
Definition: Messages.h:2843
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:25880
UInt32 MessageCounter
Counter of related messages.
Definition: Fields.h:381
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:1706
ThisType & setMaxSweepQtyToNull() noexcept
Definition: Messages.h:9072
bool strategyId(StrategyIDOptional &value) const noexcept
Client-assigned identification of a strategy.
Definition: Messages.h:12704
bool minQty(QuantityOptional &value) const noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:10030
ExecID execId() const noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:9674
Establish4(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:1427
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:18564
bool tradingSubAccount(AccountOptional &value) const noexcept
Account used for associating risk limits (when defined).
Definition: Messages.h:7558
ThisType & setExecutingTrader(StrRef value) noexcept
Identifies the trader who is executing an order.
Definition: Messages.h:19559
MessageCounter count() const noexcept
How many messages haven´t been applied?.
Definition: Messages.h:2957
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:11475
const BidirectionalBusinessHeader & businessHeader() const noexcept
Message type = QuoteStatusReport.
Definition: Messages.h:19108
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:10865
ThisType & setTransactTime(UTCTimestampNanos value) noexcept
Time of execution/order creation.
Definition: Messages.h:25566
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:22548
bool account(AccountOptional &value) const noexcept
Account mnemonic of the order.
Definition: Messages.h:14700
OutboundBusinessHeader & businessHeader() noexcept
Common header to all outbound business messages.
Definition: Messages.h:9488
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:18003
ThisType & setSessionVerId(SessionVerID value) noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:2317
RetransmitRequest12(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:3414
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:5591
static constexpr MessageType::Enum messageType() noexcept
Message type = PositionMaintenanceReport.
Definition: Messages.h:23696
SchemaTraits Schema
Used template schema.
Definition: Messages.h:20016
Enum
Indicates cross order purpose.
Definition: Fields.h:2013
EncodedLength calculateBinarySize() const noexcept
Definition: Messages.h:15365
ThisType & setSide(Side::Enum value) noexcept
Side of order.
Definition: Messages.h:7073
constexpr StrRef constructStrRef(const char(&value)[Size]) noexcept
Definition: StrRef.h:415
UInt64 AllocReportID
Unique identifier for this allocation report message.
Definition: Fields.h:237
ThisType & setRoutingInstructionToNull() noexcept
Definition: Messages.h:4685
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:386
Firm enteringFirm() const noexcept
Type of flow from client to server.
Definition: Messages.h:212
Sequence9(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:3141
static constexpr MessageType::Enum messageType() noexcept
Message type = NewOrderSingle.
Definition: Messages.h:5815
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:18085
SchemaTraits Schema
Used template schema.
Definition: Messages.h:10638
PositionMaintenanceCancelRequest501(const SbeMessage &message)
Creates an instance over the given SBE message.
Definition: Messages.h:22463
static constexpr MessageType::Enum messageType() noexcept
Message type = Negotiate.
Definition: Messages.h:117
static constexpr PosType::Enum posType() noexcept
Used to identify the type of quantity.
Definition: Messages.h:23183
PositionMaintenanceReport503 ThisType
This type alias.
Definition: Messages.h:23451
static constexpr SecurityIDSource::Enum securityIdSource() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:26768
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:14138
bool price(PriceOptional &value) const noexcept
Price per share or contract.
Definition: Messages.h:6176
QuoteStatusReport402(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:19081
ThisType & setMultiLegReportingType(MultiLegReportingType::Enum value) noexcept
Used to indicate what an Execution Report represents.
Definition: Messages.h:11169
SecurityID securityId() const noexcept
Security identification as defined by exchange.
Definition: Messages.h:7023
ThisType & resetVariableFields() noexcept
Reset all variable-length fields if any.
Definition: Messages.h:881
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:18130
SchemaTraits Schema
Used template schema.
Definition: Messages.h:5736
OutboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:23716
static constexpr const Char * className()
Definition: Messages.h:6614
SimpleOrdType::Enum ordType() const noexcept
Order type.
Definition: Messages.h:4619
bool quoteRejectReason(RejReasonOptional &value) const noexcept
Reason Quote was rejected.
Definition: Messages.h:19127
ThisType & setSessionVerId(SessionVerID value) noexcept
Session version identification: unique identification of a sequence of messages to be transmitted to/...
Definition: Messages.h:2678
ThisType & setSecondaryOrderId(OrderID value) noexcept
Exchange-generated order identifier that changes for each order modification event, or quantity replenishment in disclosed orders.
Definition: Messages.h:10821
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:5068
bool origClOrdId(ClOrdIDOptional &value) const noexcept
Value of origClOrdID field informed from the related request message.
Definition: Messages.h:12244
Side::Enum side() const noexcept
Side of order.
Definition: Messages.h:15593
bool receivedTime(UTCTimestampNanosOptional &value) const noexcept
Time of receipt of related inbound message in the gateway.
Definition: Messages.h:11413
OrderCancelRequest105(void *data, EncodedLength length, NoInit, NoCheck) noexcept
Creates an instance over the given memory block.
Definition: Messages.h:7904
BidirectionalBusinessHeader & businessHeader() noexcept
Common header to all bidirectional business messages.
Definition: Messages.h:21614
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:1734
static constexpr const Char * className()
Definition: Messages.h:418
static constexpr StrRef fixType() noexcept
FIX message type.
Definition: Messages.h:2788
static constexpr const Char * className()
Definition: Messages.h:21217
#define ONIXS_B3_BOE_UNUSED
Definition: Compiler.h:207
static constexpr FlowType::Enum clientFlow() noexcept
Type of flow from client to server.
Definition: Messages.h:769
bool multiLegReportingType(MultiLegReportingType::Enum &value) const noexcept
Used to indicate what an Execution Report represents.
Definition: Messages.h:9835
QuoteRequestReject405(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:21541
Timestamp clearingBusinessDate() const noexcept
The &#39;Clearing Business Date&#39; referred to by this request.
Definition: Messages.h:23107
ThisType & setPrice(Price8Optional value) noexcept
Price per share or contract.
Definition: Messages.h:20237
The Quote Request message is used within the context of this Forward transaction in which two parties...
Definition: Messages.h:18033
bool settlType(SettlType::Enum &value) const noexcept
Indicates who in the contract has control over evoking settlement.
Definition: Messages.h:15967
Sides sides(Sides::Size length)
Setup repeating group with the given number of entries.
Definition: Messages.h:18734
bool investorId(InvestorID &value) const noexcept
Unique identifier of investor for self trade prevention/mass cancel on behalf purposes.
Definition: Messages.h:12673
IntegralConstant< UInt64, 0ULL > NullMassActionReportIDOptional
Null value for an optional MassActionReportIDOptional field.
Definition: Fields.h:2480
ThisType & setProtectionPrice(PriceOptional value) noexcept
Conditionally returned on execution reports for Market and Stop Protect orders.
Definition: Messages.h:11089
ThisType & setTerminationCode(TerminationCode::Enum value) noexcept
Identifies the code of termination.
Definition: Messages.h:2699
ThisType & setSecurityId(SecurityID value) noexcept
Security identification as defined by exchange.
Definition: Messages.h:25326
ThisType & setTradeId(TradeIDOptional value) noexcept
The unique ID assigned to the trade entity once it is received or matched by the exchange or central ...
Definition: Messages.h:23892
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:8269
StrRef memo() const noexcept
Free ASCII format text field. This field may be used to convey client&#39;s relevant info. It&#39;s always echoed in the reports.
Definition: Messages.h:10388
bool quoteId(QuoteIDOptional &value) const noexcept
Unique identifier for quote.
Definition: Messages.h:20956
IntegralConstant< UInt64, 0ULL > NullQuoteReqIDOptional
Null value for an optional QuoteReqIDOptional field.
Definition: Fields.h:2522
ThisType & setSecurityTradingStatus(SecurityTradingStatus::Enum value) noexcept
Identifier for the instrument status.
Definition: Messages.h:13871
ClOrdID clOrdId() const noexcept
Unique identifier of the order as assigned by the market participant.
Definition: Messages.h:10787
ThisType & setText(StrRef value)
Free ASCII format text string.
Definition: Messages.h:16795
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.
Definition: Messages.h:21159
static constexpr StrRef securityExchange() noexcept
Identifies the class of the SecurityID (Exchange Symbol).
Definition: Messages.h:4591
ThisType & setAccount(AccountOptional value) noexcept
Account mnemonic of the order.
Definition: Messages.h:8531
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:20257
ExecID execId() const noexcept
Unique identifier of execution message as assigned by the exchange – unique per instrument.
Definition: Messages.h:14619
bool stopPx(PriceOptional &value) const noexcept
The stop price of a stop limit order (Conditionally required if OrdType = 4).
Definition: Messages.h:10000
InboundBusinessHeader & businessHeader() noexcept
Common header to all inbound business messages.
Definition: Messages.h:24616
ThisType & setMinQty(QuantityOptional value) noexcept
Minimum quantity of an order to be executed.
Definition: Messages.h:10039
BusinessMessageReject206(void *data, EncodedLength length, NoFieldsInit, SchemaVersion version=Schema::Version)
Initializes an instance over the given memory block With no variable-length fields initialization It ...
Definition: Messages.h:16591
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:4838
bool price(PriceOptional &value) const noexcept
Price per share or contract.
Definition: Messages.h:7187
const BidirectionalBusinessHeader & businessHeader() const noexcept
Message type = QuoteCancel.
Definition: Messages.h:20865
ThisType & reset() noexcept
Reset all variable-length and optional fields if any.
Definition: Messages.h:19838
The EstablishmentAck message is sent when an Establish message is accepted by B3. EstablishmentAck me...
Definition: Messages.h:1818
static constexpr UInt64 getMaxMessageSize(UInt8) noexcept
Maximal message size.
Definition: Messages.h:2752
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:14126
Quantity quantity() const noexcept
Overall/total quantity (e.g. number of shares).
Definition: Messages.h:25477
ThisType & setAsset(StrRef value) noexcept
Asset associated with the security, such as DOL, BGI, OZ1, WDL, CNI, etc.
Definition: Messages.h:26071
bool origClOrdId(ClOrdIDOptional &value) const noexcept
Value of origClOrdID field informed from the related request message.
Definition: Messages.h:11044
Price lastPx() const noexcept
Price of last fill.
Definition: Messages.h:13308
bool price(Price8Optional &value) const noexcept
Price per share or contract.
Definition: Messages.h:20227
ThisType & setRoutingInstructionToNull() noexcept
Definition: Messages.h:5381
bool side(Side::Enum &value) const noexcept
Side of order.
Definition: Messages.h:19394
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
Definition: Messages.h:3006
ThisType & setDeskId(StrRef value)
Identifies the trading desk.
Definition: Messages.h:9138
bool marketSegmentReceivedTime(UTCTimestampNanosOptional &value) const noexcept
Time of receipt of related inbound message in the market segment path.
Definition: Messages.h:10989
Quantity orderQty() const noexcept
Quantity ordered.
Definition: Messages.h:16165
ThisType & setSessionId(SessionID value) noexcept
Client connection identification on the gateway assigned by B3.
Definition: Messages.h:1475
bool origClOrdId(ClOrdIDOptional &value) const noexcept
ClOrdID which should be replaced.
Definition: Messages.h:5472
StrRef senderLocation() const noexcept
Identifies the original location for routing orders.
Definition: Messages.h:8796
ThisType & setEnteringFirmToNull() noexcept
Definition: Messages.h:1163
SessionID sessionId() const noexcept
Message type = NegotiateResponse.
Definition: Messages.h:685