44 enum { TemplateId = 500 };
56 checkVersion<Schema>(version);
57 checkLength(length, version);
58 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
72 checkVersion<Schema>(version);
73 checkLength(length, version);
74 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
75 resetVariableFields();
94 assert(message.
valid());
109 assert(schemaId() == Schema::Id);
110 assert(version() >= Schema::MinimalVersion);
111 assert(TemplateId == templateId());
143 return fixedStr<length>(offset);
153 setFixedStr<length>(offset, value);
166 return fixedStr<length>(offset);
177 setFixedStr<length>(offset, value);
190 return ordinary<UInt64>(offset);
201 setOrdinary(offset, value);
213 return ordinary<UInt64>(offset);
223 setOrdinary(offset, value);
235 return fixedStr<length>(offset);
245 setFixedStr<length>(offset, value);
257 return fixedStr<length>(offset);
267 setFixedStr<length>(offset, value);
276 return getVariableLengthField(
284 setVariableLengthField(
302 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
313 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
314 minimalBlockLength(version);
327 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
346 setCredentialsToNull();
354 resetVariableFields();
364 return "Negotiate500";
379 std::string toString()
const;
388 (credentials().end()));
397 SbeMessage::calculateBinarySize(tail());
405 minimalBlockLength(version) +
406 MessageHeader::Size +
407 getMinimalVariableFieldsSize(version);
410 *
this, length, minimalRequiredLength);
414 void checkVarLenFields()
const 416 variableLengthFields().
420 void checkCompatibility()
const 422 assert(TemplateId == templateId());
424 checkSchema<Schema>(schemaId(), version());
425 checkLength(bufferSize(), version());
430 struct CredentialsAccess
436 variableLengthFields().
443 ThisType& setCredentialsToNull()
446 setVariableLengthFieldToNull(
466 enum { TemplateId = 501 };
478 checkVersion<Schema>(version);
479 checkLength(length, version);
480 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
494 checkVersion<Schema>(version);
495 checkLength(length, version);
496 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
497 resetVariableFields();
507 checkCompatibility();
516 assert(message.
valid());
518 checkCompatibility();
531 assert(schemaId() == Schema::Id);
532 assert(version() >= Schema::MinimalVersion);
533 assert(TemplateId == templateId());
554 return ordinary<UInt64>(offset);
563 setOrdinary(offset, value);
574 return ordinary<UInt64>(offset);
583 setOrdinary(offset, value);
605 setOrdinary(offset, value);
625 return enumeration<FTI>(value, offset,
NullUInt8());
634 setEnumeration<FTI>(offset, value);
660 return enumeration<SplitMsg>(value, offset,
NullUInt8());
675 setEnumeration<SplitMsg>(offset, value);
696 return ordinary<UInt32>(offset);
706 setOrdinary(offset, value);
718 return ordinary<UInt64>(offset);
728 setOrdinary(offset, value);
737 return getVariableLengthField(
745 setVariableLengthField(
763 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
774 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
775 minimalBlockLength(version);
788 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
807 setCredentialsToNull();
815 setSecretKeySecureIdExpirationToNull();
816 setFaultToleranceIndicatorToNull();
819 resetVariableFields();
829 return "NegotiationResponse501";
844 std::string toString()
const;
853 (credentials().end()));
862 SbeMessage::calculateBinarySize(tail());
870 minimalBlockLength(version) +
871 MessageHeader::Size +
872 getMinimalVariableFieldsSize(version);
875 *
this, length, minimalRequiredLength);
879 void checkVarLenFields()
const 881 variableLengthFields().
885 void checkCompatibility()
const 887 assert(TemplateId == templateId());
889 checkSchema<Schema>(schemaId(), version());
890 checkLength(bufferSize(), version());
895 struct CredentialsAccess
903 variableLengthFields().
910 ThisType& setCredentialsToNull()
913 setVariableLengthFieldToNull(
933 enum { TemplateId = 502 };
945 checkVersion<Schema>(version);
946 checkLength(length, version);
947 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
961 checkVersion<Schema>(version);
962 checkLength(length, version);
963 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
964 resetVariableFields();
974 checkCompatibility();
983 assert(message.
valid());
985 checkCompatibility();
998 assert(schemaId() == Schema::Id);
999 assert(version() >= Schema::MinimalVersion);
1000 assert(TemplateId == templateId());
1011 return fixedStr<length>(value, offset);
1021 setFixedStr<length>(offset, value);
1031 setFixedStr<length>(offset,
StrRef());
1042 return ordinary<UInt64>(offset);
1051 setOrdinary(offset, value);
1062 return ordinary<UInt64>(offset);
1071 setOrdinary(offset, value);
1082 return ordinary<UInt16>(offset);
1091 setOrdinary(offset, value);
1102 return enumeration<FTI>(value, offset,
NullUInt8());
1111 setEnumeration<FTI>(offset, value);
1137 return enumeration<SplitMsg>(value, offset,
NullUInt8());
1152 setEnumeration<SplitMsg>(offset, value);
1175 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
1186 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
1187 minimalBlockLength(version);
1200 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
1212 static_cast<UInt64>(MessageHeaderBuilder::Size) +
1213 blockLength(Schema::Version);
1228 setFaultToleranceIndicatorToNull();
1229 setSplitMsgToNull();
1231 resetVariableFields();
1241 return "NegotiationReject502";
1256 std::string toString()
const;
1267 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
1268 MessageHeader::Size));
1277 SbeMessage::calculateBinarySize(tail());
1285 minimalBlockLength(version) +
1286 MessageHeader::Size +
1287 getMinimalVariableFieldsSize(version);
1290 *
this, length, minimalRequiredLength);
1293 void checkCompatibility()
const 1295 assert(TemplateId == templateId());
1297 checkSchema<Schema>(schemaId(), version());
1298 checkLength(bufferSize(), version());
1314 enum { TemplateId = 503 };
1326 checkVersion<Schema>(version);
1327 checkLength(length, version);
1328 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1342 checkVersion<Schema>(version);
1343 checkLength(length, version);
1344 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1345 resetVariableFields();
1355 checkCompatibility();
1364 assert(message.
valid());
1366 checkCompatibility();
1379 assert(schemaId() == Schema::Id);
1380 assert(version() >= Schema::MinimalVersion);
1381 assert(TemplateId == templateId());
1402 return fixedStr<length>(offset);
1412 setFixedStr<length>(offset, value);
1425 return fixedStr<length>(offset);
1436 setFixedStr<length>(offset, value);
1449 return fixedStr<length>(offset);
1460 setFixedStr<length>(offset, value);
1473 return fixedStr<length>(offset);
1484 setFixedStr<length>(offset, value);
1496 return fixedStr<length>(offset);
1506 setFixedStr<length>(offset, value);
1519 return ordinary<UInt64>(offset);
1530 setOrdinary(offset, value);
1542 return ordinary<UInt64>(offset);
1552 setOrdinary(offset, value);
1563 return ordinary<UInt32>(offset);
1572 setOrdinary(offset, value);
1584 return fixedStr<length>(offset);
1594 setFixedStr<length>(offset, value);
1606 return fixedStr<length>(offset);
1616 setFixedStr<length>(offset, value);
1628 return ordinary<UInt16>(offset);
1638 setOrdinary(offset, value);
1647 return getVariableLengthField(
1648 CredentialsAccess(),
1655 setVariableLengthField(
1656 CredentialsAccess(),
1673 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
1684 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
1685 minimalBlockLength(version);
1698 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
1717 setCredentialsToNull();
1725 resetVariableFields();
1735 return "Establish503";
1750 std::string toString()
const;
1759 (credentials().end()));
1768 SbeMessage::calculateBinarySize(tail());
1776 minimalBlockLength(version) +
1777 MessageHeader::Size +
1778 getMinimalVariableFieldsSize(version);
1781 *
this, length, minimalRequiredLength);
1785 void checkVarLenFields()
const 1787 variableLengthFields().
1791 void checkCompatibility()
const 1793 assert(TemplateId == templateId());
1795 checkSchema<Schema>(schemaId(), version());
1796 checkLength(bufferSize(), version());
1797 checkVarLenFields();
1801 struct CredentialsAccess
1807 variableLengthFields().
1814 ThisType& setCredentialsToNull()
1817 setVariableLengthFieldToNull(
1818 CredentialsAccess(),
1837 enum { TemplateId = 504 };
1849 checkVersion<Schema>(version);
1850 checkLength(length, version);
1851 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1865 checkVersion<Schema>(version);
1866 checkLength(length, version);
1867 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
1868 resetVariableFields();
1878 checkCompatibility();
1887 assert(message.
valid());
1889 checkCompatibility();
1902 assert(schemaId() == Schema::Id);
1903 assert(version() >= Schema::MinimalVersion);
1904 assert(TemplateId == templateId());
1914 return ordinary<UInt64>(offset);
1923 setOrdinary(offset, value);
1934 return ordinary<UInt64>(offset);
1943 setOrdinary(offset, value);
1954 return ordinary<UInt32>(offset);
1963 setOrdinary(offset, value);
1975 return ordinary<UInt32>(offset);
1985 setOrdinary(offset, value);
1997 return ordinary<UInt64>(offset);
2007 setOrdinary(offset, value);
2019 return ordinary<UInt16>(offset);
2029 setOrdinary(offset, value);
2041 return ordinary(value, offset,
NullUInt16());
2051 setOrdinary(offset, value);
2071 return enumeration<FTI>(value, offset,
NullUInt8());
2080 setEnumeration<FTI>(offset, value);
2106 return enumeration<SplitMsg>(value, offset,
NullUInt8());
2121 setEnumeration<SplitMsg>(offset, value);
2144 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2155 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2156 minimalBlockLength(version);
2169 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2181 static_cast<UInt64>(MessageHeaderBuilder::Size) +
2182 blockLength(Schema::Version);
2196 setSecretKeySecureIdExpirationToNull();
2197 setFaultToleranceIndicatorToNull();
2198 setSplitMsgToNull();
2200 resetVariableFields();
2210 return "EstablishmentAck504";
2225 std::string toString()
const;
2236 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
2237 MessageHeader::Size));
2246 SbeMessage::calculateBinarySize(tail());
2254 minimalBlockLength(version) +
2255 MessageHeader::Size +
2256 getMinimalVariableFieldsSize(version);
2259 *
this, length, minimalRequiredLength);
2262 void checkCompatibility()
const 2264 assert(TemplateId == templateId());
2266 checkSchema<Schema>(schemaId(), version());
2267 checkLength(bufferSize(), version());
2283 enum { TemplateId = 505 };
2295 checkVersion<Schema>(version);
2296 checkLength(length, version);
2297 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2311 checkVersion<Schema>(version);
2312 checkLength(length, version);
2313 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2314 resetVariableFields();
2324 checkCompatibility();
2333 assert(message.
valid());
2335 checkCompatibility();
2348 assert(schemaId() == Schema::Id);
2349 assert(version() >= Schema::MinimalVersion);
2350 assert(TemplateId == templateId());
2361 return fixedStr<length>(value, offset);
2371 setFixedStr<length>(offset, value);
2381 setFixedStr<length>(offset,
StrRef());
2392 return ordinary<UInt64>(offset);
2401 setOrdinary(offset, value);
2412 return ordinary<UInt64>(offset);
2421 setOrdinary(offset, value);
2432 return ordinary<UInt32>(offset);
2441 setOrdinary(offset, value);
2452 return ordinary<UInt16>(offset);
2461 setOrdinary(offset, value);
2472 return enumeration<FTI>(value, offset,
NullUInt8());
2481 setEnumeration<FTI>(offset, value);
2507 return enumeration<SplitMsg>(value, offset,
NullUInt8());
2522 setEnumeration<SplitMsg>(offset, value);
2545 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2556 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2557 minimalBlockLength(version);
2570 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2582 static_cast<UInt64>(MessageHeaderBuilder::Size) +
2583 blockLength(Schema::Version);
2598 setFaultToleranceIndicatorToNull();
2599 setSplitMsgToNull();
2601 resetVariableFields();
2611 return "EstablishmentReject505";
2626 std::string toString()
const;
2637 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
2638 MessageHeader::Size));
2647 SbeMessage::calculateBinarySize(tail());
2655 minimalBlockLength(version) +
2656 MessageHeader::Size +
2657 getMinimalVariableFieldsSize(version);
2660 *
this, length, minimalRequiredLength);
2663 void checkCompatibility()
const 2665 assert(TemplateId == templateId());
2667 checkSchema<Schema>(schemaId(), version());
2668 checkLength(bufferSize(), version());
2684 enum { TemplateId = 506 };
2696 checkVersion<Schema>(version);
2697 checkLength(length, version);
2698 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2712 checkVersion<Schema>(version);
2713 checkLength(length, version);
2714 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
2715 resetVariableFields();
2725 checkCompatibility();
2734 assert(message.
valid());
2736 checkCompatibility();
2749 assert(schemaId() == Schema::Id);
2750 assert(version() >= Schema::MinimalVersion);
2751 assert(TemplateId == templateId());
2761 return ordinary<UInt64>(offset);
2770 setOrdinary(offset, value);
2781 return ordinary<UInt32>(offset);
2790 setOrdinary(offset, value);
2801 return enumeration<FTI>(value, offset,
NullUInt8());
2810 setEnumeration<FTI>(offset, value);
2833 return enumeration<KeepAliveLapsed>(offset);
2847 setEnumeration<KeepAliveLapsed>(offset, value);
2861 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2872 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2873 minimalBlockLength(version);
2886 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
2898 static_cast<UInt64>(MessageHeaderBuilder::Size) +
2899 blockLength(Schema::Version);
2913 setFaultToleranceIndicatorToNull();
2915 resetVariableFields();
2925 return "Sequence506";
2940 std::string toString()
const;
2951 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
2952 MessageHeader::Size));
2961 SbeMessage::calculateBinarySize(tail());
2969 minimalBlockLength(version) +
2970 MessageHeader::Size +
2971 getMinimalVariableFieldsSize(version);
2974 *
this, length, minimalRequiredLength);
2977 void checkCompatibility()
const 2979 assert(TemplateId == templateId());
2981 checkSchema<Schema>(schemaId(), version());
2982 checkLength(bufferSize(), version());
2998 enum { TemplateId = 507 };
3010 checkVersion<Schema>(version);
3011 checkLength(length, version);
3012 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3026 checkVersion<Schema>(version);
3027 checkLength(length, version);
3028 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3029 resetVariableFields();
3039 checkCompatibility();
3048 assert(message.
valid());
3050 checkCompatibility();
3063 assert(schemaId() == Schema::Id);
3064 assert(version() >= Schema::MinimalVersion);
3065 assert(TemplateId == templateId());
3076 return fixedStr<length>(value, offset);
3086 setFixedStr<length>(offset, value);
3096 setFixedStr<length>(offset,
StrRef());
3107 return ordinary<UInt64>(offset);
3116 setOrdinary(offset, value);
3128 return ordinary<UInt64>(offset);
3138 setOrdinary(offset, value);
3149 return ordinary<UInt16>(offset);
3158 setOrdinary(offset, value);
3175 return enumeration<SplitMsg>(value, offset,
NullUInt8());
3190 setEnumeration<SplitMsg>(offset, value);
3213 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3224 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3225 minimalBlockLength(version);
3238 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3250 static_cast<UInt64>(MessageHeaderBuilder::Size) +
3251 blockLength(Schema::Version);
3266 setSplitMsgToNull();
3268 resetVariableFields();
3278 return "Terminate507";
3293 std::string toString()
const;
3304 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
3305 MessageHeader::Size));
3314 SbeMessage::calculateBinarySize(tail());
3322 minimalBlockLength(version) +
3323 MessageHeader::Size +
3324 getMinimalVariableFieldsSize(version);
3327 *
this, length, minimalRequiredLength);
3330 void checkCompatibility()
const 3332 assert(TemplateId == templateId());
3334 checkSchema<Schema>(schemaId(), version());
3335 checkLength(bufferSize(), version());
3351 enum { TemplateId = 508 };
3363 checkVersion<Schema>(version);
3364 checkLength(length, version);
3365 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3379 checkVersion<Schema>(version);
3380 checkLength(length, version);
3381 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3382 resetVariableFields();
3392 checkCompatibility();
3401 assert(message.
valid());
3403 checkCompatibility();
3416 assert(schemaId() == Schema::Id);
3417 assert(version() >= Schema::MinimalVersion);
3418 assert(TemplateId == templateId());
3428 return ordinary<UInt64>(offset);
3437 setOrdinary(offset, value);
3449 return ordinary(value, offset,
NullUInt64());
3459 setOrdinary(offset, value);
3480 return ordinary<UInt64>(offset);
3490 setOrdinary(offset, value);
3503 return ordinary<UInt32>(offset);
3514 setOrdinary(offset, value);
3525 return ordinary<UInt16>(offset);
3534 setOrdinary(offset, value);
3548 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3559 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3560 minimalBlockLength(version);
3573 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3585 static_cast<UInt64>(MessageHeaderBuilder::Size) +
3586 blockLength(Schema::Version);
3600 setLastUUIdToNull();
3602 resetVariableFields();
3612 return "RetransmitRequest508";
3627 std::string toString()
const;
3638 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
3639 MessageHeader::Size));
3648 SbeMessage::calculateBinarySize(tail());
3656 minimalBlockLength(version) +
3657 MessageHeader::Size +
3658 getMinimalVariableFieldsSize(version);
3661 *
this, length, minimalRequiredLength);
3664 void checkCompatibility()
const 3666 assert(TemplateId == templateId());
3668 checkSchema<Schema>(schemaId(), version());
3669 checkLength(bufferSize(), version());
3685 enum { TemplateId = 509 };
3697 checkVersion<Schema>(version);
3698 checkLength(length, version);
3699 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3713 checkVersion<Schema>(version);
3714 checkLength(length, version);
3715 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
3716 resetVariableFields();
3726 checkCompatibility();
3735 assert(message.
valid());
3737 checkCompatibility();
3750 assert(schemaId() == Schema::Id);
3751 assert(version() >= Schema::MinimalVersion);
3752 assert(TemplateId == templateId());
3762 return ordinary<UInt64>(offset);
3771 setOrdinary(offset, value);
3782 return ordinary(value, offset,
NullUInt64());
3791 setOrdinary(offset, value);
3811 return ordinary<UInt64>(offset);
3820 setOrdinary(offset, value);
3831 return ordinary<UInt32>(offset);
3840 setOrdinary(offset, value);
3851 return ordinary<UInt16>(offset);
3860 setOrdinary(offset, value);
3877 return enumeration<SplitMsg>(value, offset,
NullUInt8());
3892 setEnumeration<SplitMsg>(offset, value);
3915 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3926 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3927 minimalBlockLength(version);
3940 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
3952 static_cast<UInt64>(MessageHeaderBuilder::Size) +
3953 blockLength(Schema::Version);
3967 setLastUUIdToNull();
3968 setSplitMsgToNull();
3970 resetVariableFields();
3980 return "Retransmission509";
3995 std::string toString()
const;
4006 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
4007 MessageHeader::Size));
4016 SbeMessage::calculateBinarySize(tail());
4024 minimalBlockLength(version) +
4025 MessageHeader::Size +
4026 getMinimalVariableFieldsSize(version);
4029 *
this, length, minimalRequiredLength);
4032 void checkCompatibility()
const 4034 assert(TemplateId == templateId());
4036 checkSchema<Schema>(schemaId(), version());
4037 checkLength(bufferSize(), version());
4053 enum { TemplateId = 510 };
4065 checkVersion<Schema>(version);
4066 checkLength(length, version);
4067 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4081 checkVersion<Schema>(version);
4082 checkLength(length, version);
4083 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4084 resetVariableFields();
4094 checkCompatibility();
4103 assert(message.
valid());
4105 checkCompatibility();
4118 assert(schemaId() == Schema::Id);
4119 assert(version() >= Schema::MinimalVersion);
4120 assert(TemplateId == templateId());
4131 return fixedStr<length>(value, offset);
4141 setFixedStr<length>(offset, value);
4151 setFixedStr<length>(offset,
StrRef());
4162 return ordinary<UInt64>(offset);
4171 setOrdinary(offset, value);
4182 return ordinary(value, offset,
NullUInt64());
4191 setOrdinary(offset, value);
4211 return ordinary<UInt64>(offset);
4220 setOrdinary(offset, value);
4231 return ordinary<UInt16>(offset);
4240 setOrdinary(offset, value);
4257 return enumeration<SplitMsg>(value, offset,
NullUInt8());
4272 setEnumeration<SplitMsg>(offset, value);
4295 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
4306 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
4307 minimalBlockLength(version);
4320 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
4332 static_cast<UInt64>(MessageHeaderBuilder::Size) +
4333 blockLength(Schema::Version);
4348 setLastUUIdToNull();
4349 setSplitMsgToNull();
4351 resetVariableFields();
4361 return "RetransmitReject510";
4376 std::string toString()
const;
4387 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
4388 MessageHeader::Size));
4397 SbeMessage::calculateBinarySize(tail());
4405 minimalBlockLength(version) +
4406 MessageHeader::Size +
4407 getMinimalVariableFieldsSize(version);
4410 *
this, length, minimalRequiredLength);
4413 void checkCompatibility()
const 4415 assert(TemplateId == templateId());
4417 checkSchema<Schema>(schemaId(), version());
4418 checkLength(bufferSize(), version());
4434 enum { TemplateId = 513 };
4446 checkVersion<Schema>(version);
4447 checkLength(length, version);
4448 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4462 checkVersion<Schema>(version);
4463 checkLength(length, version);
4464 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4465 resetVariableFields();
4475 checkCompatibility();
4484 assert(message.
valid());
4486 checkCompatibility();
4499 assert(schemaId() == Schema::Id);
4500 assert(version() >= Schema::MinimalVersion);
4501 assert(TemplateId == templateId());
4511 return ordinary<UInt64>(offset);
4520 setOrdinary(offset, value);
4531 return ordinary<UInt32>(offset);
4540 setOrdinary(offset, value);
4551 return ordinary<UInt32>(offset);
4560 setOrdinary(offset, value);
4581 return enumeration<SplitMsg>(value, offset,
NullUInt8());
4600 setEnumeration<SplitMsg>(offset, value);
4623 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
4634 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
4635 minimalBlockLength(version);
4648 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
4660 static_cast<UInt64>(MessageHeaderBuilder::Size) +
4661 blockLength(Schema::Version);
4675 setSplitMsgToNull();
4677 resetVariableFields();
4687 return "NotApplied513";
4702 std::string toString()
const;
4713 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
4714 MessageHeader::Size));
4723 SbeMessage::calculateBinarySize(tail());
4731 minimalBlockLength(version) +
4732 MessageHeader::Size +
4733 getMinimalVariableFieldsSize(version);
4736 *
this, length, minimalRequiredLength);
4739 void checkCompatibility()
const 4741 assert(TemplateId == templateId());
4743 checkSchema<Schema>(schemaId(), version());
4744 checkLength(bufferSize(), version());
4760 enum { TemplateId = 514 };
4772 checkVersion<Schema>(version);
4773 checkLength(length, version);
4774 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4788 checkVersion<Schema>(version);
4789 checkLength(length, version);
4790 init(TemplateId, minimalBlockLength(version), blockLength(version), Schema::Id);
4791 resetVariableFields();
4801 checkCompatibility();
4810 assert(message.
valid());
4812 checkCompatibility();
4825 assert(schemaId() == Schema::Id);
4826 assert(version() >= Schema::MinimalVersion);
4827 assert(TemplateId == templateId());
4848 setOrdinary(offset, value);
4868 return ordinary<UInt32>(offset);
4877 setOrdinary(offset, value);
4889 return ordinary<Int32>(offset);
4899 setOrdinary(offset, value);
4910 return enumeration<SideReq>(offset);
4919 setEnumeration<SideReq>(offset, value);
4930 return ordinary<UInt32>(offset);
4939 setOrdinary(offset, value);
4957 return fixedStr<length>(offset);
4973 setFixedStr<length>(offset, value);
4991 return fixedStr<length>(offset);
5007 setFixedStr<length>(offset, value);
5020 return ordinary<UInt64>(offset);
5031 setOrdinary(offset, value);
5044 return ordinary<UInt64>(offset);
5055 setOrdinary(offset, value);
5067 return ordinary<UInt64>(offset);
5077 setOrdinary(offset, value);
5099 setOrdinary(offset, value);
5121 return fixedStr<length>(offset);
5132 setFixedStr<length>(offset, value);
5143 return ordinary(value, offset,
NullUInt32());
5152 setOrdinary(offset, value);
5174 return ordinary(value, offset,
NullUInt32());
5185 setOrdinary(offset, value);
5211 FieldValue fieldValue;
5251 return enumeration<OrderTypeReq>(offset);
5260 setEnumeration<OrderTypeReq>(offset, value);
5271 return enumeration<TimeInForce>(value, offset,
NullUInt8());
5280 setEnumeration<TimeInForce>(offset, value);
5301 return enumeration<ManualOrdIndReq>(offset);
5313 setEnumeration<ManualOrdIndReq>(offset, value);
5326 return ordinary<ExecInst>(offset);
5337 setOrdinary(offset, value);
5350 return enumeration<ExecMode>(value, offset,
NullCharNULL());
5361 setEnumeration<ExecMode>(offset, value);
5383 return enumeration<BooleanNULL>(value, offset,
NullUInt8());
5394 setEnumeration<BooleanNULL>(offset, value);
5414 return enumeration<BooleanNULL>(value, offset,
NullUInt8());
5423 setEnumeration<BooleanNULL>(offset, value);
5447 return enumeration<ShortSaleType>(value, offset,
NullEnumNULL());
5460 setEnumeration<ShortSaleType>(offset, value);
5493 setOrdinary(offset, value);
5528 setOrdinary(offset, value);
5551 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
5562 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
5563 minimalBlockLength(version);
5576 ONIXS_ILINK3_ASSERT(version >= Schema::MinimalVersion),
5588 static_cast<UInt64>(MessageHeaderBuilder::Size) +
5589 blockLength(Schema::Version);
5606 setDisplayQtyToNull();
5607 setExpireDateToNull();
5608 setTimeInForceToNull();
5609 setExecutionModeToNull();
5610 setLiquidityFlagToNull();
5611 setManagedOrderToNull();
5612 setShortSaleTypeToNull();
5613 setDiscretionPriceToNull();
5614 setReservationPriceToNull();
5616 resetVariableFields();
5626 return "NewOrderSingle514";
5641 std::string toString()
const;
5652 static_cast<ptrdiff_t>(SbeMessage::blockLength()) +
5653 MessageHeader::Size));
5662 SbeMessage::calculateBinarySize(tail());
5670 minimalBlockLength(version) +
5671 MessageHeader::Size +
5672 getMinimalVariableFieldsSize(version);
5675 *
this, length, minimalRequiredLength);
5678 void checkCompatibility()
const 5680 assert(TemplateId == templateId());
5682 checkSchema<Schema>(schemaId(), version());
5683 checkLength(bufferSize(), version());
5699 enum { TemplateId = 515 };